pip install pypdf python-multipart

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
from pypdf import PdfReader # [NEW]
import numpy as np

print("正在載入 Embedding 模型...")
model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')

# 這次我們不預設資料，改用一個空的列表，等使用者上傳
knowledge_base = []
knowledge_embeddings = None

def add_pdf_to_knowledge_base(file_stream):
    """
    讀取 PDF -> 抓文字 -> 切割 -> 轉向量 -> 存入知識庫
    """
    global knowledge_base, knowledge_embeddings
    
    # 1. 讀取 PDF 文字
    reader = PdfReader(file_stream)
    text = ""
    for page in reader.pages:
        text += page.extract_text() + "\n"
    
    # 2. 文字切割 (Chunking)
    # LLM 一次讀不完這麽多字，我們要切成小塊 (例如每 200 字一塊)
    chunk_size = 200
    chunks = [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)]
    
    print(f"PDF 處理完畢，切成 {len(chunks)} 個片段")

    # 3. 更新知識庫
    new_items = [{"id": len(knowledge_base) + i, "content": chunk} for i, chunk in enumerate(chunks)]
    knowledge_base.extend(new_items)
    
    # 4. 重新計算向量索引 (簡單暴力法：全部重算)
    # 在真實系統中，我們會用 Vector DB (如 ChromaDB) 來處理，不用每次重算
    texts = [item["content"] for item in knowledge_base]
    knowledge_embeddings = model.encode(texts)
    
    return len(chunks)

def search_knowledge_base(query, top_k=3):
    """
    搜尋功能 (跟之前一樣，但加了防呆機制)
    """
    global knowledge_embeddings
    
    # 如果知識庫是空的，直接回傳空
    if not knowledge_base or knowledge_embeddings is None:
        return []

    query_embedding = model.encode([query])
    similarities = cosine_similarity(query_embedding, knowledge_embeddings)
    top_indices = similarities[0].argsort()[-top_k:][::-1]
    
    results = []
    for idx in top_indices:
        score = similarities[0][idx]
        if score > 0.3: 
            results.append(knowledge_base[idx]["content"])
            
    return results

# ... (前面的 import 不變)
from fastapi import UploadFile, File # [NEW] 引入檔案處理模組
from rag_service import search_knowledge_base, add_pdf_to_knowledge_base # [NEW] 引入新函式

# ... (app = FastAPI... 中間設定不變) ...

# [NEW] 上傳檔案的 API
@app.post("/upload")
async def upload_file(file: UploadFile = File(...)):
    try:
        # 把檔案內容傳給 rag_service 處理
        chunk_count = add_pdf_to_knowledge_base(file.file)
        return {"message": f"成功讀取 {file.filename}，新增了 {chunk_count} 個知識片段！"}
    except Exception as e:
        return {"error": str(e)}

# ... (chat_with_ai 函式保持不變) ...
# 注意：記得確認 chat_with_ai 裡面有呼叫 search_knowledge_base

<!-- 在標題下方 -->
<div style="margin-bottom: 10px; padding: 10px; background: #fff3cd; border: 1px solid #ffeeba; border-radius: 5px;">
    <h3>📚 知識庫上傳</h3>
    <input type="file" id="pdf-upload" accept=".pdf">
    <button onclick="uploadPDF()" style="background-color: #ffc107; color: black;">上傳 PDF</button>
    <span id="upload-status" style="margin-left: 10px; font-size: 0.9em; color: #666;"></span>
</div>

<div class="chat-box" id="chat-box">
    </div>

async function uploadPDF() {
            const fileInput = document.getElementById("pdf-upload");
            const statusText = document.getElementById("upload-status");
            const file = fileInput.files[0];

            if (!file) {
                alert("請先選擇 PDF 檔案！");
                return;
            }

            statusText.innerText = "正在處理中... (請稍候)";

            const formData = new FormData();
            formData.append("file", file);

            try {
                const response = await fetch("http://127.0.0.1:8000/upload", {
                    method: "POST",
                    body: formData
                });
                
                const data = await response.json();
                if (data.message) {
                    statusText.innerText = "✅ " + data.message;
                    statusText.style.color = "green";
                } else {
                    statusText.innerText = "❌ 上傳失敗：" + data.error;
                    statusText.style.color = "red";
                }
            } catch (error) {
                console.error(error);
                statusText.innerText = "❌ 連線錯誤";
            }
        }

pip freeze > requirements.txt

# 1. 選擇基底映像檔 (就像選擇要灌什麼作業系統)
# 我們選一個輕量級的 Python 3.12 環境
FROM python:3.12-slim

# 2. 設定工作目錄 (在箱子裡建立一個 /app 資料夾)
WORKDIR /app

# 3. 把你電腦裡的 requirements.txt 複製進箱子
COPY requirements.txt .

# 4. 在箱子裡安裝套件
# --no-cache-dir 可以讓箱子小一點
RUN pip install --no-cache-dir -r requirements.txt

# 5. 把你電腦裡的所有程式碼 (main.py, server.py...) 複製進箱子
COPY . .

# 6. 告訴 Docker，這個程式會開 8000 port
EXPOSE 8000

# 7. 當箱子啟動時，要執行的指令
# 注意：這裡的 --host 0.0.0.0 是關鍵，一定要設成這樣外部才連得進去
CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8000"]

docker build -t my-ai-system .

pip install openai

from openai import OpenAI

# 1. 設定連線資訊
# base_url 是關鍵，這行告訴程式：「不要連去 OpenAI，改連去 Groq」
client = OpenAI(
    api_key="剛剛申請的API KEY", 
    base_url="https://api.groq.com/openai/v1"
)

print("--- 免費 AI 聊天機器人 (Groq Llama3) 啟動 ---")
print("--- 輸入 'quit' 可以離開程式 ---")

while True:
    # 2. 讓使用者輸入
    user_input = input("\n你：")
    
    if user_input.lower() == "quit":
        print("再見！")
        break

    # 3. 呼叫 AI (這裡使用開源模型 Llama3-8b)
    try:
        completion = client.chat.completions.create(
            model="llama-3.3-70b-versatile",  # 指定模型名稱
            messages=[
                {"role": "system", "content": "你是一個繁體中文的 AI 助教，回答簡潔有力。"},
                {"role": "user", "content": user_input}
            ]
        )

        # 4. 取得回答
        ai_response = completion.choices[0].message.content
        print(f"AI：{ai_response}")
        
    except Exception as e:
        print(f"發生錯誤：{e}")

from fastapi.responses import StreamingResponse # [NEW] 引入串流回應

# [NEW] 這裡我們不直接回傳，而是寫一個 "產生器 (Generator)"
# 它的功能是：一邊收 Groq 的資料，一邊吐給前端
def get_ai_response_stream(user_message: str):
    try:
        completion = client.chat.completions.create(
            model="llama-3.3-70b-versatile",
            messages=[
                {"role": "system", "content": "你是一個繁體中文 AI 助教。"},
                {"role": "user", "content": user_message}
            ],
            stream=True  # [關鍵] 告訴 Groq 我們要用串流模式
        )
        
        for chunk in completion:
            # 檢查這個碎片有沒有內容
            content = chunk.choices[0].delta.content
            if content:
                yield content  # "yield" 意思是產出一個碎片就馬上送出去
                
    except Exception as e:
        yield f"Error: {str(e)}"

@app.post("/chat")
def chat_with_ai(data: UserInput):
    print(f"收到訊息 (串流模式)：{data.message}")
    
    # 回傳一個 "串流回應"，而不是一般的 JSON
    return StreamingResponse(
        get_ai_response_stream(data.message), 
        media_type="text/plain"
    )

<script>
        async function sendMessage() {
            const inputField = document.getElementById("user-input");
            const sendBtn = document.getElementById("send-btn");
            const chatBox = document.getElementById("chat-box");
            const message = inputField.value.trim();

            if (!message) return;

            // 1. 顯示使用者訊息
            appendMessage(message, "user");
            inputField.value = "";
            sendBtn.disabled = true;
            sendBtn.innerText = "思考中...";

            // 2. 準備接收 AI 的回答 (先建立一個空的對話框)
            const aiMessageDiv = appendMessage("", "ai"); 

            try {
                const response = await fetch("http://127.0.0.1:8000/chat", {
                    method: "POST",
                    headers: { "Content-Type": "application/json" },
                    body: JSON.stringify({ message: message })
                });

                // [NEW] 處理串流資料的關鍵邏輯
                const reader = response.body.getReader();
                const decoder = new TextDecoder("utf-8");

                while (true) {
                    const { done, value } = await reader.read();
                    if (done) break; // 如果讀完了就跳出迴圈

                    // 把讀到的二進位資料轉成文字
                    const chunk = decoder.decode(value, { stream: true });
                    
                    // 把文字 "追加" 到目前的對話框裡，而不是覆蓋
                    aiMessageDiv.innerText += chunk;
                    
                    // 自動捲動到底部
                    chatBox.scrollTop = chatBox.scrollHeight;
                }

            } catch (error) {
                aiMessageDiv.innerText = "連線發生錯誤。";
                console.error(error);
            }

            sendBtn.disabled = false;
            sendBtn.innerText = "發送";
        }

        // 輔助功能：建立訊息框並回傳該元素 (讓我們可以持續更新它)
        function appendMessage(text, sender) {
            const chatBox = document.getElementById("chat-box");
            const div = document.createElement("div");
            div.classList.add("message", sender);
            div.innerText = text;
            chatBox.appendChild(div);
            chatBox.scrollTop = chatBox.scrollHeight;
            return div; // 回傳這個 div，讓外面的程式可以繼續塞字進去
        }

        function handleEnter(event) {
            if (event.key === "Enter") sendMessage();
        }
    </script>

from typing import List, Dict # [NEW] 引入型別定義

# [NEW] 修改資料模型：不再只是單一字串，而是接受一個列表 (List)
# 格式會像這樣：[{"role": "user", "content": "hi"}, {"role": "assistant", "content": "hello"}]
class UserInput(BaseModel):
    messages: List[Dict[str, str]]

def get_ai_response_stream(messages_history: List[Dict[str, str]]):
    try:
        # [NEW] 這裡不再是寫死的 system prompt + user message
        # 而是直接把前端傳來的 "整包歷史紀錄" 丟給 Groq
        
        # 我們可以在最前面偷偷加一個 System Prompt 設定 AI 人設
        system_prompt = [{"role": "system", "content": "你是一個繁體中文 AI 助教，記憶力很好。"}]
        full_context = system_prompt + messages_history

        completion = client.chat.completions.create(
            model="llama-3.3-70b-versatile",
            messages=full_context, # 這裡放入完整的對話歷史
            stream=True
        )
        
        for chunk in completion:
            content = chunk.choices[0].delta.content
            if content:
                yield content

    except Exception as e:
        yield f"Error: {str(e)}"

@app.post("/chat")
def chat_with_ai(data: UserInput):
    # print(f"收到歷史對話，長度：{len(data.messages)}") # 除錯用
    return StreamingResponse(
        get_ai_response_stream(data.messages), 
        media_type="text/plain"
    )

<script>
        // [NEW] 用來暫存對話紀錄的變數
        let conversationHistory = [];

        async function sendMessage() {
            const inputField = document.getElementById("user-input");
            const sendBtn = document.getElementById("send-btn");
            const chatBox = document.getElementById("chat-box");
            const message = inputField.value.trim();

            if (!message) return;

            // 1. 顯示並紀錄使用者的訊息
            appendMessage(message, "user");
            // [NEW] 把使用者的話加入歷史紀錄
            conversationHistory.push({ "role": "user", "content": message });

            inputField.value = "";
            sendBtn.disabled = true;
            sendBtn.innerText = "思考中...";

            const aiMessageDiv = appendMessage("", "ai"); 
            let fullAiResponse = ""; // 用來收集 AI 的完整回答

            try {
                // [NEW] 傳送 "整包歷史紀錄" 給後端
                const response = await fetch("http://127.0.0.1:8000/chat", {
                    method: "POST",
                    headers: { "Content-Type": "application/json" },
                    body: JSON.stringify({ messages: conversationHistory }) 
                });

                const reader = response.body.getReader();
                const decoder = new TextDecoder("utf-8");

                while (true) {
                    const { done, value } = await reader.read();
                    if (done) break;

                    const chunk = decoder.decode(value, { stream: true });
                    aiMessageDiv.innerText += chunk;
                    fullAiResponse += chunk; // 收集碎片
                    chatBox.scrollTop = chatBox.scrollHeight;
                }
                
                // [NEW] AI 講完後，把它的話也加入歷史紀錄
                conversationHistory.push({ "role": "assistant", "content": fullAiResponse });

            } catch (error) {
                aiMessageDiv.innerText = "連線發生錯誤。";
                console.error(error);
            }

            sendBtn.disabled = false;
            sendBtn.innerText = "發送";
        }

        function appendMessage(text, sender) {
            const chatBox = document.getElementById("chat-box");
            const div = document.createElement("div");
            div.classList.add("message", sender);
            div.innerText = text;
            chatBox.appendChild(div);
            chatBox.scrollTop = chatBox.scrollHeight;
            return div;
        }

        function handleEnter(event) {
            if (event.key === "Enter") sendMessage();
        }
    </script>

pip install sentence-transformers scikit-learn

# 這只是一個簡單的模擬資料庫 (Dictionary)
# 實務上這裡會是 PDF 檔案或資料庫
knowledge_base = [
    {
        "id": 1,
        "content": "關於請假：本公司員工每年享有 14 天特休，請假需提前 3 天在 HR 系統申請。"
    },
    {
        "id": 2,
        "content": "關於加班費：平日加班費為 1.33 倍，假日加班費為 1.66 倍，需經理核准。"
    },
    {
        "id": 3,
        "content": "關於午餐：公司每日中午 12:00 提供免費便當，素食者需在 10:00 前登記。"
    },
    {
        "id": 4,
        "content": "關於在家工作 (WFH)：每週三為固定 WFH 日，其餘時間需進辦公室。"
    }
]

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
from faq_data import knowledge_base
import numpy as np

print("正在載入 Embedding 模型 (第一次會比較久)...")
# 下載一個輕量級的中文模型 (這會存在你的電腦裡)
model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')

# 1. 先把知識庫裡的每一條資料，都轉換成「向量 (Vector)」並存起來
# 這樣待會搜尋速度才會快
print("正在建立索引...")
knowledge_texts = [item["content"] for item in knowledge_base]
knowledge_embeddings = model.encode(knowledge_texts)
print("索引建立完成！")

def search_knowledge_base(query, top_k=1):
    """
    輸入使用者的問題 (query)，回傳最相似的 k 筆資料
    """
    # 2. 把使用者的問題也變成向量
    query_embedding = model.encode([query])
    
    # 3. 計算相似度 (Cosine Similarity)
    # 比較「問題向量」跟所有「知識庫向量」的距離
    similarities = cosine_similarity(query_embedding, knowledge_embeddings)
    
    # 4. 找出分數最高的 top_k 個結果
    # argsort 會回傳排序後的索引，我們取最後 top_k 個 (分數最高的)
    top_indices = similarities[0].argsort()[-top_k:][::-1]
    
    results = []
    for idx in top_indices:
        score = similarities[0][idx]
        if score > 0.3: # 設定一個門檻，相關度太低就不採用 (避免誤導)
            results.append(knowledge_base[idx]["content"])
            
    return results

# 測試用 (當你直接執行這個檔案時會跑這段)
if __name__ == "__main__":
    test_query = "請問加班有錢拿嗎？"
    print(f"\n測試搜尋：{test_query}")
    print(search_knowledge_base(test_query))

from rag_service import search_knowledge_base # [NEW] 引入搜尋功能

# ... (中間設定不變)
def get_ai_response_stream(messages_history: List[Dict[str, str]]):
    try:
        # 1. 抓出使用者最新的一句話
        latest_user_message = messages_history[-1]["content"]
        
        # 2. [RAG 核心] 先去知識庫搜尋有沒有相關資料
        print(f"正在搜尋知識庫：{latest_user_message}")
        retrieved_info = search_knowledge_base(latest_user_message)
        
        system_instruction = "你是一個繁體中文 AI 助教。"
        
        # 3. 如果有搜到資料，就把它塞進 System Prompt 裡
        if retrieved_info:
            print(f"搜到資料：{retrieved_info}")
            context_str = "\n".join(retrieved_info)
            # 這裡就是 RAG 的精隨：把資料貼給 AI 看
            system_instruction += f"\n\n【參考資料】：\n{context_str}\n\n請根據上述【參考資料】回答使用者的問題。如果資料裡沒有答案，請說不知道，不要瞎掰。"
        else:
            print("沒搜到相關資料")

        # 重新組裝 messages
        # 我們把原本的 messages_history 保留，但把第一句 system prompt 換掉
        current_messages = [{"role": "system", "content": system_instruction}] 
        
        # 把使用者之前的對話紀錄接在後面 (除了第一句 system prompt)
        # 注意：這裡邏輯要小心，我們假設 messages_history 都是 user/assistant 的對話
        for msg in messages_history:
             if msg["role"] != "system":
                 current_messages.append(msg)

        completion = client.chat.completions.create(
            model="llama-3.3-70b-versatile",
            messages=current_messages,
            stream=True
        )
        
        for chunk in completion:
            content = chunk.choices[0].delta.content
            if content:
                yield content

    except Exception as e:
        yield f"Error: {str(e)}"

# ... (後面不變)

import torch
import torch.nn as nn

class LSTMModel(nn.Module):
    def __init__(self, input_size=1, hidden_size=128, output_size=1):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
            out, _ = self.lstm(x)    # [batch, seq_len, hidden_size]
            out = self.fc(out)       # [batch, seq_len, output_size]
            return out