version: '3.8'
services:
  # Milvus向量數據庫
  etcd:
    container_name: milvus-etcd
    image: quay.io/coreos/etcd:v3.5.18
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
      - ETCD_AUTO_COMPACTION_RETENTION=1000
    volumes:
      - ${DOCKER_VOLUME_DIRECTORY:-.}/volumes/etcd:/etcd
    command: etcd -advertise-client-urls=http://etcd:2379 -listen-client-urls http://0.0.0.0:2379 --data-dir /etcd
    healthcheck:
      test: ["CMD", "etcdctl", "endpoint", "health"]
      interval: 30s
      timeout: 20s
      retries: 3
  # RustFS對象存儲（替代MinIO）
  rustfs:
    container_name: milvus-rustfs
    image: rustfs/rustfs:1.0.0-alpha.58
    environment:
      - RUSTFS_VOLUMES=/data/rustfs0,/data/rustfs1,/data/rustfs2,/data/rustfs3
      - RUSTFS_ADDRESS=0.0.0.0:9000
      - RUSTFS_CONSOLE_ADDRESS=0.0.0.0:9001
      - RUSTFS_CONSOLE_ENABLE=true
      - RUSTFS_ACCESS_KEY=rustfsadmin
      - RUSTFS_SECRET_KEY=rustfsadmin
    ports:
      - "9000:9000"  # S3 API端口
      - "9001:9001"  # 控制枱端口
    volumes:
      - rustfs_data_0:/data/rustfs0
      - rustfs_data_1:/data/rustfs1
      - rustfs_data_2:/data/rustfs2
      - rustfs_data_3:/data/rustfs3
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "sh", "-c", "curl -f http://localhost:9000/health && curl -f http://localhost:9001/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
  # Milvus向量數據庫
  milvus-standalone:
    container_name: milvus-standalone
    image: milvusdb/milvus:v2.6.0
    command: ["milvus", "run", "standalone"]
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: rustfs:9000  # 使用RustFS作為存儲後端
    volumes:
      - ${DOCKER_VOLUME_DIRECTORY:-.}/volumes/milvus:/var/lib/milvus
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - "etcd"
      - "rustfs"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9091/healthz"]
      interval: 30s
      start_period: 90s
      timeout: 20s
      retries: 3
  # Attu：Milvus的可視化管理界面
  attu:
    container_name: milvus-attu
    image: zilliz/attu:v2.6
    environment:
      - MILVUS_URL=milvus-standalone:19530
    ports:
      - "8000:3000"
    restart: unless-stopped
volumes:
  rustfs_data_0:
  rustfs_data_1:
  rustfs_data_2:
  rustfs_data_3:

docker compose up -d

docker ps

python -m venv chatbot-env
source chatbot-env/bin/activate  # Linux/macOS
# 或 chatbot-env\Scripts\activate  # Windows
pip install pymilvus==2.6.0
pip install openai==1.3.0
pip install boto3==1.28.0  # 用於連接RustFS
pip install fastapi==0.104.0
pip install uvicorn==0.24.0
pip install python-multipart==0.0.6

import os
import glob
from milvus import Milvus, DataType
def load_markdown_files(folder_path):
    """加載Markdown文檔"""
    files = glob.glob(os.path.join(folder_path, "**", "*.md"), recursive=True)
    docs = []
    for file_path in files:
        with open(file_path, "r", encoding="utf-8") as f:
            content = f.read()
            docs.append({
                "file_path": file_path,
                "content": content,
                "file_name": os.path.basename(file_path)
            })
    return docs
def split_into_chunks(text, max_length=500):
    """將長文本分割為適合向量化的塊"""
    chunks = []
    current_chunk = []
    current_length = 0
    for line in text.split("\n"):
        line_length = len(line)
        if current_length + line_length < max_length:
            current_chunk.append(line)
            current_length += line_length
        else:
            if current_chunk:
                chunks.append(" ".join(current_chunk))
            current_chunk = [line]
            current_length = line_length
    if current_chunk:
        chunks.append(" ".join(current_chunk))
    return chunks
def get_embedding(text, model="text-embedding-3-large"):
    """使用OpenAI API獲取文本向量"""
    from openai import OpenAI
    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    response = client.embeddings.create(
        model=model,
        input=text
    )
    return [data.embedding for data in response.data]

def create_milvus_collection():
    """創建Milvus集合用於存儲文檔向量"""
    client = Milvus(host='localhost', port='19530')
    # 定義集合結構
    collection_name = "knowledge_base"
    # 如果集合已存在，先刪除
    if client.has_collection(collection_name):
        client.drop_collection(collection_name)
    # 創建字段定義
    fields = [
        FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
        FieldSchema(name="file_name", dtype=DataType.VARCHAR, max_length=500),
        FieldSchema(name="content", dtype=DataType.VARCHAR, max_length=10000),
        FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=3072)  # text-embedding-3-large維度
    ]
    schema = CollectionSchema(fields, description="知識庫文檔集合")
    collection = Collection(name=collection_name, schema=schema)
    # 創建索引優化檢索速度
    index_params = {
        "index_type": "HNSW",
        "metric_type": "L2",
        "params": {"M": 8, "efConstruction": 64}
    }
    collection.create_index("embedding", index_params)
    return collection

def build_knowledge_base(docs_folder_path):
    """構建知識庫的完整流程"""
    # 1. 加載文檔
    print("加載Markdown文檔...")
    documents = load_markdown_files(docs_folder_path)
    print(f"共加載 {len(documents)} 個文檔")
    # 2. 創建Milvus集合
    collection = create_milvus_collection()
    all_chunks = []
    all_embeddings = []
    # 3. 處理每個文檔
    for doc in documents:
        chunks = split_into_chunks(doc["content"])
        print(f"文檔 {doc['file_name']} 分割為 {len(chunks)} 個塊")
        for chunk in chunks:
            all_chunks.append({
                "file_name": doc["file_name"],
                "content": chunk
            })
    # 4. 批量生成向量（減少API調用）
    batch_size = 10  # OpenAI限制
    for i in range(0, len(all_chunks), batch_size):
        batch_chunks = all_chunks[i:i+batch_size]
        batch_texts = [chunk["content"] for chunk in batch_chunks]
        print(f"生成向量 {i+1}-{i+len(batch_chunks)}/{len(all_chunks)}")
        embeddings = get_embedding(batch_texts)
        all_embeddings.extend(embeddings)
    # 5. 存入Milvus
    entities = [
        [chunk["file_name"] for chunk in all_chunks],
        [chunk["content"] for chunk in all_chunks],
        all_embeddings
    ]
    collection.insert(entities)
    collection.flush()
    print(f"知識庫構建完成，共存入 {len(all_chunks)} 個文檔塊")
    return collection

class RAGEngine:
    def __init__(self, milvus_host='localhost', milvus_port=19530):
        self.client = Milvus(host=milvus_host, port=milvus_port)
        self.collection = Collection("knowledge_base")
        self.collection.load()
    def retrieve_similar_docs(self, query, top_k=3):
        """檢索與查詢最相關的文檔"""
        # 將查詢轉換為向量
        query_embedding = get_embedding([query])[0]
        # 在Milvus中搜索相似文檔
        search_params = {"metric_type": "L2", "params": {"nprobe": 10}}
        results = self.collection.search(
            data=[query_embedding],
            anns_field="embedding",
            param=search_params,
            limit=top_k,
            output_fields=["file_name", "content"]
        )
        # 提取相關文檔內容
        relevant_docs = []
        for hits in results:
            for hit in hits:
                relevant_docs.append({
                    "file_name": hit.entity.get("file_name"),
                    "content": hit.entity.get("content"),
                    "score": hit.score
                })
        return relevant_docs
    def generate_answer(self, query, context_docs):
        """基於檢索到的上下文生成回答"""
        from openai import OpenAI
        client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
        # 構建上下文
        context = "\n\n".join([doc["content"] for doc in context_docs])
        # 構建prompt
        prompt = f"""基於以下上下文信息，回答用户的問題。如果上下文信息不足以回答問題，請如實告知。
上下文信息：
{context}
用户問題：{query}
請根據上下文提供準確、有用的回答："""
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": "你是一個專業的助手，根據提供的上下文信息準確回答用户問題。"},
                {"role": "user", "content": prompt}
            ],
            temperature=0.1  # 低温度值確保回答穩定性
        )
        return response.choices[0].message.content
    def query(self, question, top_k=3):
        """完整的RAG查詢流程"""
        # 1. 檢索相關文檔
        relevant_docs = self.retrieve_similar_docs(question, top_k)
        # 2. 生成回答
        answer = self.generate_answer(question, relevant_docs)
        return {
            "answer": answer,
            "sources": relevant_docs
        }

class ConversationManager:
    def __init__(self, max_history=10):
        self.conversation_history = []
        self.max_history = max_history
    def add_message(self, role, content):
        """添加對話消息"""
        self.conversation_history.append({"role": role, "content": content})
        # 保持歷史記錄長度
        if len(self.conversation_history) > self.max_history * 2:  # 用户和助手消息各10條
            self.conversation_history = self.conversation_history[-self.max_history * 2:]
    def get_conversation_context(self):
        """獲取當前對話上下文"""
        return self.conversation_history.copy()
    def clear_history(self):
        """清空對話歷史"""
        self.conversation_history = []

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
import uvicorn
app = FastAPI(title="Chatbot API", version="1.0.0")
# 允許跨域請求
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)
# 數據模型
class ChatRequest(BaseModel):
    message: str
    conversation_id: str = None
class ChatResponse(BaseModel):
    answer: str
    sources: list
    conversation_id: str
# 全局實例
rag_engine = RAGEngine()
conversation_managers = {}  # 按會話ID管理對話歷史
def get_conversation_manager(conversation_id):
    """獲取或創建對話管理器"""
    if conversation_id not in conversation_managers:
        conversation_managers[conversation_id] = ConversationManager()
    return conversation_managers[conversation_id]
@app.post("/chat", response_model=ChatResponse)
async def chat_endpoint(request: ChatRequest):
    try:
        conversation_mgr = get_conversation_manager(request.conversation_id or "default")
        # 添加用户消息到歷史
        conversation_mgr.add_message("user", request.message)
        # 獲取對話上下文用於增強檢索
        conversation_context = conversation_mgr.get_conversation_context()
        contextual_query = self._build_contextual_query(request.message, conversation_context)
        # 使用RAG引擎獲取回答
        result = rag_engine.query(contextual_query)
        # 添加助手回答到歷史
        conversation_mgr.add_message("assistant", result["answer"])
        return ChatResponse(
            answer=result["answer"],
            sources=result["sources"],
            conversation_id=request.conversation_id or "default"
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
def _build_contextual_query(current_query, conversation_history):
    """結合對話歷史構建上下文相關的查詢"""
    if len(conversation_history) <= 2:  # 只有當前查詢
        return current_query
    # 提取最近幾輪對話作為上下文
    recent_history = conversation_history[-4:]  # 最近兩輪對話（用户+助手）
    context = "之前的對話背景："
    for msg in recent_history:
        role = "用户" if msg["role"] == "user" else "助手"
        context += f"\n{role}: {msg['content']}"
    return f"{context}\n\n基於以上對話背景，當前問題：{current_query}"
@app.get("/health")
async def health_check():
    return {"status": "healthy", "service": "chatbot-api"}
if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

import React, { useState, useRef, useEffect } from 'react';
export default function ChatbotInterface() {
  const [messages, setMessages] = useState([]);
  const [input, setInput] = useState('');
  const [loading, setLoading] = useState(false);
  const messagesEndRef = useRef(null);
  const scrollToBottom = () => {
    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
  };
  useEffect(scrollToBottom, [messages]);
  const sendMessage = async () => {
    if (!input.trim()) return;
    const userMessage = { role: 'user', content: input };
    setMessages(prev => [...prev, userMessage]);
    setInput('');
    setLoading(true);
    try {
      const response = await fetch('http://localhost:8000/chat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          message: input,
          conversation_id: 'default'
        }),
      });
      const data = await response.json();
      const botMessage = {
        role: 'assistant',
        content: data.answer,
        sources: data.sources
      };
      setMessages(prev => [...prev, botMessage]);
    } catch (error) {
      console.error('Error:', error);
      const errorMessage = {
        role: 'assistant',
        content: '抱歉，暫時無法回答問題，請稍後重試。'
      };
      setMessages(prev => [...prev, errorMessage]);
    } finally {
      setLoading(false);
    }
  };
  return (
    

      
        {messages.map((msg, index) => (
          
            
              {msg.content}
              {msg.sources && (
                
                  參考來源: {msg.sources.map(s => s.file_name).join(', ')}
                
              )}
            
          
        ))}
        {loading && (
          
            
              
                
                
                
              
            
          
        )}
        
      
      
         setInput(e.target.value)}
          onKeyPress={(e) => e.key === 'Enter' && sendMessage()}
          placeholder="輸入您的問題..."
          disabled={loading}
        />
        
          發送
        
      
    
  );
}