大厂闭源模型越来越贵？这个开源项目让你免费玩转生成式AI，还能本地部署隐私无忧

# 创建一个名为openai的虚拟环境，指定Python版本为3.10
conda create -n openai python=3.10

# 激活这个虚拟环境
conda activate openai

# 创建虚拟环境
python -m venv openai_env

# 激活虚拟环境
# Windows系统
openai_env\Scripts\activate
# Linux或macOS系统
source openai_env/bin/activate

# 克隆项目仓库
git clone https://github.com/Anil-matcha/Open-Generative-AI.git

# 进入项目目录
cd Open-Generative-AI

# 如果使用requirements.txt
pip install -r requirements.txt

# 或者如果使用pyproject.toml和poetry
pip install poetry
poetry install

nvidia-smi

# 下载CUDA安装包（以Ubuntu为例）
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin
sudo mv cuda-ubuntu2204.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda-repo-ubuntu2204-11-8-local_11.8.0-520.61.05-1_amd64.deb
sudo dpkg -i cuda-repo-ubuntu2204-11-8-local_11.8.0-520.61.05-1_amd64.deb
sudo apt-get update
sudo apt-get install cuda

# 临时添加到当前会话的PATH
export PATH=/usr/local/cuda-11.8/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda-11.8/lib64:$LD_LIBRARY_PATH

# 或者永久添加到~/.bashrc
echo 'export PATH=/usr/local/cuda-11.8/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-11.8/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

# 解压cuDNN包
tar -xf cudnn-linux-x86_64-8.x.x.x_cuda11.y-archive.tar.xz

# 复制文件到CUDA目录
sudo cp cuda/include/cudnn*.h /usr/local/cuda/include/
sudo cp cuda/lib64/libcudnn* /usr/local/cuda/lib64/
sudo chmod a+r /usr/local/cuda/include/cudnn*.h /usr/local/cuda/lib64/libcudnn*

# 验证Python环境和基础依赖
import sys
print(f"Python版本: {sys.version}")
print(f"Python路径: {sys.executable}")

# 验证PyTorch安装
try:
    import torch
    print(f"\nPyTorch版本: {torch.__version__}")
    print(f"CUDA是否可用: {torch.cuda.is_available()}")
    if torch.cuda.is_available():
        print(f"CUDA版本: {torch.version.cuda}")
        print(f"GPU数量: {torch.cuda.device_count()}")
        print(f"GPU名称: {torch.cuda.get_device_name(0)}")
except ImportError:
    print("PyTorch未安装")

# 验证transformers库
try:
    import transformers
    print(f"\nTransformers版本: {transformers.__version__}")
except ImportError:
    print("Transformers未安装")

# 验证项目核心模块
try:
    import open_generative_ai
    print(f"\nOpen-Generative-AI已正确安装")
    print(f"版本: {open_generative_ai.__version__}")
except ImportError as e:
    print(f"\nOpen-Generative-AI导入失败: {e}")

python verify_installation.py

# 首先导入核心模块
from open_generative_ai import OpenAIClient

# 初始化客户端
client = OpenAIClient(
    model="gpt-3.5-turbo",  # 可以指定任意支持的模型
    api_base="http://localhost:8000"  # 本地部署的地址
)

# 简单的文本补全
prompt = "在一个遥远的星系中，有一艘宇宙飞船正在穿越虫洞"
response = client.completions.create(
    prompt=prompt,
    max_tokens=200,  # 生成的最大token数
    temperature=0.7,  # 控制随机性，0-2之间，越高越随机
    top_p=0.9  # 核采样参数
)

print("生成的文本:")
print(response.choices[0].text)

# 使用聊天补全接口
messages = [
    {"role": "system", "content": "你是一位博学多才的历史老师，擅长用生动的故事讲解历史事件。"},
    {"role": "user", "content": "请给我讲讲秦始皇统一六国的故事。"},
    {"role": "assistant", "content": "好的，让我来为你讲述这个精彩的历史故事..."},
    {"role": "user", "content": "那他又为什么要焚书坑儒呢？"}
]

response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=messages,
    max_tokens=500,
    temperature=0.8
)

print("助手的回复:")
print(response.choices[0].message.content)

from open_generative_ai import OpenAIClient
import numpy as np

# 初始化客户端
client = OpenAIClient(
    model="text-embedding-ada-002",  # 使用专门的嵌入模型
    api_base="http://localhost:8000"
)

# 获取单个文本的嵌入向量
text = "人工智能正在改变我们的生活方式和工作模式"
embedding = client.embeddings.create(
    input=text,
    model="text-embedding-ada-002"
)

# 提取向量结果
vector = embedding.data[0].embedding
print(f"嵌入向量维度: {len(vector)}")
print(f"向量前5个值: {vector[:5]}")

# 批量获取嵌入向量
texts = [
    "机器学习是人工智能的核心技术",
    "深度学习在图像识别领域取得了突破",
    "自然语言处理让人机交互更加自然",
    "计算机视觉使机器能够看懂世界"
]

embeddings = client.embeddings.create(
    input=texts,
    model="text-embedding-ada-002"
)

# 处理批量结果
for i, embedding_data in enumerate(embeddings.data):
    print(f"文本{i+1}的嵌入向量前5个值: {embedding_data.embedding[:5]}")

# 计算文本相似度（余弦相似度）
def cosine_similarity(vec1, vec2):
    """计算两个向量的余弦相似度"""
    vec1 = np.array(vec1)
    vec2 = np.array(vec2)
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

# 比较前两个文本的相似度
similarity = cosine_similarity(
    embeddings.data[0].embedding,
    embeddings.data[1].embedding
)
print(f"\n文本1和文本2的余弦相似度: {similarity:.4f}")

from open_generative_ai import OpenAIClient
import json

# 定义可用的函数
functions = [
    {
        "name": "get_weather",
        "description": "获取指定城市的天气信息",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "城市名称，如北京、上海、东京"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "温度单位"
                }
            },
            "required": ["city"]
        }
    },
    {
        "name": "search_hotels",
        "description": "搜索符合条件的酒店",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "城市名称"
                },
                "min_price": {
                    "type": "number",
                    "description": "最低价格（元）"
                },
                "max_price": {
                    "type": "number",
                    "description": "最高价格（元）"
                }
            },
            "required": ["city"]
        }
    }
]

client = OpenAIClient(api_base="http://localhost:8000")

messages = [
    {"role": "user", "content": "我想去北京玩，帮我查一下那边酒店的價格，在300到800元之间的有哪些？"}
]

response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=messages,
    functions=functions,
    function_call="auto"  # 自动决定是否调用函数
)

# 检查是否有函数调用
message = response.choices[0].message

if message.function_call:
    # 解析函数调用
    function_name = message.function_call.name
    arguments = json.loads(message.function_call.arguments)

    print(f"模型决定调用函数: {function_name}")
    print(f"传入参数: {arguments}")

    # 这里模拟函数执行结果
    # 实际应用中，你需要实现真正的函数逻辑
    if function_name == "search_hotels":
        hotel_results = [
            {"name": "北京饭店", "price": 580, "rating": 4.5},
            {"name": "王府半岛酒店", "price": 750, "rating": 4.8},
            {"name": "北京希尔顿", "price": 620, "rating": 4.6}
        ]

        # 将函数结果返回给模型
        messages.append(message)  # 添加助手的函数调用消息

        # 模拟函数执行结果
        function_result_message = {
            "role": "function",
            "name": function_name,
            "content": json.dumps(hotel_results)
        }

        # 再次调用模型，让它根据函数结果生成回复
        messages.append(function_result_message)

        final_response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=messages
        )

        print("\n最终回复:")
        print(final_response.choices[0].message.content)
else:
    print("模型回复:")
    print(message.content)

from open_generative_ai import OpenAIClient

client = OpenAIClient(api_base="http://localhost:8000")

# 启用流式输出
stream = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "user", "content": "用三段话介绍一下人工智能的发展历史"}
    ],
    max_tokens=500,
    stream=True  # 启用流式输出
)

print("AI正在生成回复（流式输出）:\n")

# 逐步接收并显示内容
full_response = ""
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        content = chunk.choices[0].delta.content
        full_response += content
        print(content, end="", flush=True)  # 实时打印，不换行

print("\n\n流式输出完成!")
print(f"总字数: {len(full_response)}")

# 图像理解功能
from open_generative_ai import OpenAIClient
import base64

# 读取本地图片并转换为base64
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

client = OpenAIClient(api_base="http://localhost:8000")

# 如果模型支持视觉功能，可以使用图片进行对话
try:
    image_base64 = encode_image("example_image.jpg")

    messages = [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "请描述这张图片的内容"
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{image_base64}"
                    }
                }
            ]
        }
    ]

    response = client.chat.completions.create(
        model="gpt-4-vision-preview",  # 需要支持视觉的模型
        messages=messages,
        max_tokens=300
    )

    print("图片描述:")
    print(response.choices[0].message.content)

except Exception as e:
    print(f"图像处理功能暂不可用: {e}")
    print("可能原因：1. 当前模型不支持视觉功能 2. 需要更新到支持多模态的模型版本")

# document_processor.py
# 文档处理模块，负责文档的加载、分割和向量化

import os
import json
from typing import List, Dict, Tuple
from pathlib import Path

class DocumentProcessor:
    """文档处理器，用于加载、分割和向量化文档"""

    def __init__(self, client, chunk_size: int = 500, chunk_overlap: int = 50):
        """
        初始化文档处理器

        Args:
            client: OpenAIClient实例
            chunk_size: 每个文本块的最大字符数
            chunk_overlap: 相邻文本块之间的重叠字符数
        """
        self.client = client
        self.chunk_size = chunk_size
        self.chunk_overlap = chunk_overlap
        self.documents = []
        self.chunks = []
        self.embeddings = []

    def load_text_file(self, file_path: str) -> str:
        """加载文本文件"""
        with open(file_path, 'r', encoding='utf-8') as f:
            return f.read()

    def load_markdown_file(self, file_path: str) -> str:
        """加载Markdown文件"""
        with open(file_path, 'r', encoding='utf-8') as f:
            return f.read()

    def load_pdf_file(self, file_path: str) -> str:
        """
        加载PDF文件
        注意：需要安装PyPDF2或pdfplumber库
        """
        try:
            import PyPDF2
            text = ""
            with open(file_path, 'rb') as f:
                reader = PyPDF2.PdfReader(f)
                for page in reader.pages:
                    text += page.extract_text() + "\n"
            return text
        except ImportError:
            print("请安装PyPDF2: pip install PyPDF2")
            raise

    def load_document(self, file_path: str) -> str:
        """根据文件扩展名自动选择加载方法"""
        path = Path(file_path)
        extension = path.suffix.lower()

        loaders = {
            '.txt': self.load_text_file,
            '.md': self.load_markdown_file,
            '.markdown': self.load_markdown_file,
            '.pdf': self.load_pdf_file
        }

        if extension not in loaders:
            raise ValueError(f"不支持的文件类型: {extension}")

        return loaders[extension](file_path)

    def split_text(self, text: str) -> List[str]:
        """将长文本分割成小块"""
        chunks = []
        start = 0

        while start < len(text):
            # 计算当前块的结束位置
            end = start + self.chunk_size

            # 如果不是最后一块，尝试在句子边界处分割
            if end < len(text):
                # 寻找最近的句子结束符
                for sep in ['。', '！', '？', '.', '!', '?', '\n']:
                    last_sep = text.rfind(sep, start, end)
                    if last_sep > start:
                        end = last_sep + 1
                        break

            # 提取文本块
            chunk = text[start:end].strip()
            if chunk:
                chunks.append(chunk)

            # 移动到下一个块（包含重叠部分）
            start = end - self.chunk_overlap

        return chunks

    def process_document(self, file_path: str, metadata: Dict = None) -> List[Dict]:
        """
        处理单个文档

        Args:
            file_path: 文档路径
            metadata: 文档的元数据信息

        Returns:
            处理后的文本块列表，每个块包含文本和元数据
        """
        print(f"正在加载文档: {file_path}")
        text = self.load_document(file_path)

        print("正在分割文档...")
        chunks = self.split_text(text)
        print(f"分割完成，共{len(chunks)}个文本块")

        # 为每个块添加元数据
        processed_chunks = []
        for i, chunk in enumerate(chunks):
            chunk_data = {
                "text": chunk,
                "metadata": metadata or {},
                "metadata"]["file_path"] = file_path,
                "metadata"]["chunk_index"] = i
            }
            processed_chunks.append(chunk_data)

        self.chunks.extend(processed_chunks)
        return processed_chunks

    def process_documents(self, file_paths: List[str]) -> List[Dict]:
        """批量处理多个文档"""
        all_chunks = []
        for path in file_paths:
            chunks = self.process_document(path)
            all_chunks.extend(chunks)
        return all_chunks

    def create_embeddings(self, show_progress: bool = True) -> List[List[float]]:
        """
        为所有文本块创建嵌入向量

        Returns:
            嵌入向量列表
        """
        print("正在创建嵌入向量...")

        all_embeddings = []
        total = len(self.chunks)

        # 批量处理以提高效率
        batch_size = 20

        for i in range(0, total, batch_size):
            batch = self.chunks[i:i+batch_size]
            texts = [chunk["text"] for chunk in batch]

            # 调用API获取嵌入向量
            response = self.client.embeddings.create(
                input=texts,
                model="text-embedding-ada-002"
            )

            for data in response.data:
                all_embeddings.append(data.embedding)

            if show_progress:
                progress = min(i + batch_size, total)
                print(f"进度: {progress}/{total}")

        self.embeddings = all_embeddings
        print(f"嵌入向量创建完成，共{len(all_embeddings)}个")

        return all_embeddings

    def save_index(self, file_path: str):
        """保存索引数据到文件"""
        index_data = {
            "chunks": self.chunks,
            "embeddings": self.embeddings
        }
        with open(file_path, 'w', encoding='utf-8') as f:
            json.dump(index_data, f, ensure_ascii=False)
        print(f"索引已保存到: {file_path}")

    def load_index(self, file_path: str):
        """从文件加载索引数据"""
        with open(file_path, 'r', encoding='utf-8') as f:
            index_data = json.load(f)
        self.chunks = index_data["chunks"]
        self.embeddings = index_data["embeddings"]
        print(f"索引已加载，共{len(self.chunks)}个文本块")

# retrieval.py
# 问答检索模块，负责在文档中检索相关内容

import numpy as np
from typing import List, Dict, Tuple, Optional

class RetrievalEngine:
    """检索引擎，用于在文档中查找相关内容"""

    def __init__(self, chunks: List[Dict], embeddings: List[List[float]]):
        """
        初始化检索引擎

        Args:
            chunks: 文本块列表
            embeddings: 对应的嵌入向量列表
        """
        self.chunks = chunks
        self.embeddings = np.array(embeddings)
        self.dimension = self.embeddings.shape[1]

    def cosine_similarity(self, vec1: np.ndarray, vec2: np.ndarray) -> float:
        """计算两个向量的余弦相似度"""
        dot_product = np.dot(vec1, vec2)
        norm_product = np.linalg.norm(vec1) * np.linalg.norm(vec2)
        return dot_product / (norm_product + 1e-10)  # 防止除零

    def find_similar_chunks(
        self, 
        query: str, 
        query_embedding: List[float],
        top_k: int = 5,
        threshold: float = 0.0
    ) -> List[Tuple[Dict, float]]:
        """
        查找与查询最相似的文本块

        Args:
            query: 查询文本
            query_embedding: 查询的嵌入向量
            top_k: 返回的最相似块数量
            threshold: 相似度阈值，低于此值的块将被过滤

        Returns:
            (文本块, 相似度)元组列表，按相似度降序排列
        """
        query_vec = np.array(query_embedding)
        similarities = []

        for i, embedding in enumerate(self.embeddings):
            sim = self.cosine_similarity(query_vec, embedding)
            if sim >= threshold:
                similarities.append((self.chunks[i], sim))

        # 按相似度降序排序
        similarities.sort(key=lambda x: x[1], reverse=True)

        return similarities[:top_k]

    def batch_find_similar(
        self,
        queries: List[str],
        query_embeddings: List[List[float]],
        top_k: int = 5
    ) -> List[List[Tuple[Dict, float]]]:
        """批量查询"""
        results = []
        for query, embedding in zip(queries, query_embeddings):
            similar = self.find_similar_chunks(query, embedding, top_k)
            results.append(similar)
        return results


class QAEngine:
    """问答引擎，结合检索和生成进行问答"""

    def __init__(self, retrieval_engine: RetrievalEngine, client):
        """
        初始化问答引擎

        Args:
            retrieval_engine: 检索引擎实例
            client: OpenAIClient实例
        """
        self.retrieval = retrieval_engine
        self.client = client

    def get_query_embedding(self, query: str) -> List[float]:
        """获取查询的嵌入向量"""
        response = self.client.embeddings.create(
            input=query,
            model="text-embedding-ada-002"
        )
        return response.data[0].embedding

    def build_context(self, similar_chunks: List[Tuple[Dict, float]]) -> str:
        """根据相似块构建上下文"""
        context_parts = []

        for i, (chunk, similarity) in enumerate(similar_chunks, 1):
            source = chunk["metadata"].get("file_path", "未知来源")
            chunk_index = chunk["metadata"].get("chunk_index", 0)

            part = f"[文档{i}] 来源: {source} (相似度: {similarity:.4f})\n{chunk['text']}\n"
            context_parts.append(part)

        return "\n---\n".join(context_parts)

    def ask(
        self, 
        question: str, 
        top_k: int = 5,
        threshold: float = 0.5,
        max_context_tokens: int = 3000
    ) -> Dict:
        """
        提问并获取答案

        Args:
            question: 问题
            top_k: 参考的文档块数量
            threshold: 相似度阈值
            max_context_tokens: 最大上下文token数（约等于字符数/2）

        Returns:
            包含答案和参考信息的字典
        """
        # 1. 获取问题的嵌入向量
        print("正在分析问题...")
        query_embedding = self.get_query_embedding(question)

        # 2. 检索相关文档
        print("正在检索相关文档...")
        similar_chunks = self.retrieval.find_similar_chunks(
            question, 
            query_embedding, 
            top_k=top_k,
            threshold=threshold
        )

        if not similar_chunks:
            return {
                "question": question,
                "answer": "抱歉，我在文档库中没有找到与您问题相关的内容。",
                "sources": [],
                "similarities": []
            }

        # 3. 构建上下文
        print(f"找到{len(similar_chunks)}个相关文档块")
        context = self.build_context(similar_chunks)

        # 如果上下文太长，截断
        if len(context) > max_context_tokens * 2:
            context = context[:max_context_tokens * 2]

        # 4. 构建提示词
        system_prompt = """你是一个专业的文档问答助手。你的任务是根据提供的文档内容回答用户的问题。

重要规则：
1. 只根据文档内容回答，不要编造信息
2. 如果文档中没有提到相关信息，明确指出这一点
3. 回答要清晰、有条理
4. 可以引用文档中的具体内容来支持你的回答
5. 如果多个文档的内容有冲突，请指出来源差异"""

        user_prompt = f"""## 文档内容：

{context}

## 用户问题：

{question}

## 要求：
请根据上述文档内容回答用户的问题。"""

        # 5. 调用语言模型生成答案
        print("正在生成答案...")
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_prompt}
            ],
            max_tokens=1000,
            temperature=0.3  # 较低的随机性，保持回答的准确性
        )

        answer = response.choices[0].message.content

        # 6. 整理结果
        sources = []
        similarities = []
        for chunk, sim in similar_chunks:
            sources.append(chunk["metadata"].get("file_path", "未知来源"))
            similarities.append(sim)

        return {
            "question": question,
            "answer": answer,
            "sources": sources,
            "similarities": similarities
        }

# document_qa_system.py
# 完整的文档问答系统

import os
import argparse
from pathlib import Path

from open_generative_ai import OpenAIClient
from document_processor import DocumentProcessor
from retrieval import RetrievalEngine, QAEngine

class DocumentQASystem:
    """文档问答系统主类"""

    def __init__(self, api_base: str = "http://localhost:8000"):
        """初始化系统"""
        self.client = OpenAIClient(api_base=api_base)
        self.processor = None
        self.retrieval = None
        self.qa_engine = None

    def build_index(
        self, 
        documents: List[str], 
        index_path: str = "document_index.json",
        chunk_size: int = 500
    ):
        """
        构建文档索引

        Args:
            documents: 文档路径列表
            index_path: 索引文件保存路径
            chunk_size: 文本块大小
        """
        print("=" * 50)
        print("开始构建文档索引")
        print("=" * 50)

        # 初始化处理器
        self.processor = DocumentProcessor(
            client=self.client,
            chunk_size=chunk_size
        )

        # 处理文档
        for doc_path in documents:
            metadata = {
                "file_name": os.path.basename(doc_path),
                "file_size": os.path.getsize(doc_path)
            }
            self.processor.process_document(doc_path, metadata)

        # 创建嵌入向量
        self.processor.create_embeddings()

        # 保存索引
        self.processor.save_index(index_path)

        # 初始化检索引擎
        self.retrieval = RetrievalEngine(
            chunks=self.processor.chunks,
            embeddings=self.processor.embeddings
        )

        # 初始化问答引擎
        self.qa_engine = QAEngine(self.retrieval, self.client)

        print("索引构建完成!")

    def load_index(self, index_path: str):
        """加载已有索引"""
        print(f"正在加载索引: {index_path}")
        self.processor = DocumentProcessor(client=self.client)
        self.processor.load_index(index_path)

        self.retrieval = RetrievalEngine(
            chunks=self.processor.chunks,
            embeddings=self.processor.embeddings
        )

        self.qa_engine = QAEngine(self.retrieval, self.client)
        print("索引加载完成!")

    def ask(self, question: str, top_k: int = 5):
        """
        提问

        Args:
            question: 问题
            top_k: 参考的文档块数量
        """
        if not self.qa_engine:
            raise ValueError("请先构建或加载索引")

        result = self.qa_engine.ask(question, top_k=top_k)

        print("\n" + "=" * 50)
        print("问题:", result["question"])
        print("=" * 50)
        print("\n答案:")
        print(result["answer"])
        print("\n" + "-" * 50)
        print("参考来源:")
        for i, (source, similarity) in enumerate(
            zip(result["sources"], result["similarities"]), 1
        ):
            print(f"  {i}. {source} (相似度: {similarity:.4f})")

        return result


# 主程序入口
def main():
    parser = argparse.ArgumentParser(description="文档问答系统")
    parser.add_argument("--api-base", default="http://localhost:8000", 
                        help="API服务地址")
    parser.add_argument("--documents", nargs="+", 
                        help="要处理的文档路径")
    parser.add_argument("--index", default="document_index.json",
                        help="索引文件路径")
    parser.add_argument("--chunk-size", type=int, default=500,
                        help="文本块大小")
    parser.add_argument("--interactive", action="store_true",
                        help="交互模式")

    args = parser.parse_args()

    # 初始化系统
    system = DocumentQASystem(api_base=args.api_base)

    # 如果指定了文档，构建索引
    if args.documents:
        system.build_index(
            documents=args.documents,
            index_path=args.index,
            chunk_size=args.chunk_size
        )
    # 否则尝试加载已有索引
    elif os.path.exists(args.index):
        system.load_index(args.index)
    else:
        print("错误: 请指定要处理的文档，或确保索引文件存在")
        return

    # 交互模式
    if args.interactive:
        print("\n" + "=" * 50)
        print("文档问答系统 - 交互模式")
        print("输入问题进行查询，输入'quit'退出")
        print("=" * 50 + "\n")

        while True:
            question = input("你: ").strip()
            if question.lower() in ['quit', 'exit', '退出']:
                print("再见!")
                break
            if not question:
                continue
            system.ask(question)
            print()


if __name__ == "__main__":
    main()

# 构建索引
python document_qa_system.py \
    --api-base http://localhost:8000 \
    --documents ./docs/faq.md ./docs/guide.txt \
    --index my_index.json \
    --chunk-size 500

# 交互式问答
python document_qa_system.py \
    --api-base http://localhost:8000 \
    --index my_index.json \
    --interactive

# conversation_manager.py
# 对话管理模块，处理多轮对话上下文

import json
from datetime import datetime
from typing import List, Dict, Optional, Callable
from dataclasses import dataclass, field, asdict

@dataclass
class Message:
    """消息类"""
    role: str  # "user", "assistant", "system"
    content: str
    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
    metadata: Dict = field(default_factory=dict)

@dataclass
class Conversation:
    """会话类"""
    id: str
    messages: List[Message] = field(default_factory=list)
    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
    updated_at: str = field(default_factory=lambda: datetime.now().isoformat())
    metadata: Dict = field(default_factory=dict)

class ConversationManager:
    """对话管理器"""

    MAX_HISTORY_LENGTH = 20  # 最大历史消息数
    SYSTEM_PROMPT = """你是一个专业、友好的客服助手。请根据以下知识库内容回答用户的问题。

回答原则：
1. 首先向用户问好，了解用户的需求
2. 根据知识库内容准确回答用户的问题
3. 如果知识库中没有相关信息，诚实地告知用户
4. 保持友好、耐心的态度
5. 如果用户问题不清晰，适当追问
6. 在回答结束时，询问用户是否还有其他问题

当前时间: {current_time}"""

    def __init__(self, knowledge_base: Optional[List[Dict]] = None):
        """
        初始化对话管理器

        Args:
            knowledge_base: 知识库列表，每个条目包含question和answer
        """
        self.conversations: Dict[str, Conversation] = {}
        self.knowledge_base = knowledge_base or []
        self.current_time = datetime.now().strftime("%Y年%m月%d日 %H:%M")

    def create_conversation(self, user_id: str, metadata: Dict = None) -> str:
        """创建新会话"""
        conversation_id = f"{user_id}_{datetime.now().strftime('%Y%m%d%H%M%S')}"

        conversation = Conversation(
            id=conversation_id,
            metadata=metadata or {}
        )

        # 添加系统提示
        system_message = Message(
            role="system",
            content=self.SYSTEM_PROMPT.format(current_time=self.current_time)
        )
        conversation.messages.append(system_message)

        self.conversations[conversation_id] = conversation
        return conversation_id

    def get_conversation(self, conversation_id: str) -> Optional[Conversation]:
        """获取会话"""
        return self.conversations.get(conversation_id)

    def add_message(
        self, 
        conversation_id: str, 
        role: str, 
        content: str,
        metadata: Dict = None
    ) -> bool:
        """添加消息"""
        conversation = self.get_conversation(conversation_id)
        if not conversation:
            return False

        message = Message(
            role=role,
            content=content,
            metadata=metadata or {}
        )

        conversation.messages.append(message)

        # 限制历史消息长度
        if len(conversation.messages) > self.MAX_HISTORY_LENGTH:
            # 保留系统提示和最近的对话
            system_msg = conversation.messages[0]
            conversation.messages = [system_msg] + conversation.messages[-(self.MAX_HISTORY_LENGTH-1):]

        # 更新会话时间
        conversation.updated_at = datetime.now().isoformat()

        return True

    def get_messages(self, conversation_id: str) -> List[Dict]:
        """获取会话消息列表"""
        conversation = self.get_conversation(conversation_id)
        if not conversation:
            return []
        return [asdict(msg) for msg in conversation.messages]

    def format_messages_for_api(
        self, 
        conversation_id: str,
        include_knowledge: bool = True
    ) -> List[Dict]:
        """
        将消息格式化为API调用格式

        Args:
            conversation_id: 会话ID
            include_knowledge: 是否在系统提示中包含知识库
        """
        messages = self.get_messages(conversation_id)
        formatted = []

        for msg in messages:
            if msg["role"] == "system":
                # 在系统提示中添加知识库
                content = msg["content"]
                if include_knowledge and self.knowledge_base:
                    kb_text = self._format_knowledge_base()
                    content += "\n\n## 知识库内容:\n" + kb_text

                formatted.append({
                    "role": "system",
                    "content": content
                })
            else:
                formatted.append({
                    "role": msg["role"],
                    "content": msg["content"]
                })

        return formatted

    def _format_knowledge_base(self) -> str:
        """格式化知识库"""
        if not self.knowledge_base:
            return "（暂无知识库内容）"

        kb_parts = []
        for i, item in enumerate(self.knowledge_base, 1):
            q = item.get("question", "")
            a = item.get("answer", "")
            kb_parts.append(f"Q{i}: {q}\nA{i}: {a}")

        return "\n\n".join(kb_parts)

    def clear_conversation(self, conversation_id: str) -> bool:
        """清除会话历史"""
        conversation = self.get_conversation(conversation_id)
        if not conversation:
            return False

        # 保留系统提示
        system_msg = conversation.messages[0] if conversation.messages else None
        conversation.messages = []
        if system_msg:
            conversation.messages.append(system_msg)

        return True


class CustomerServiceBot:
    """客服机器人主类"""

    def __init__(
        self, 
        client,
        knowledge_base: List[Dict],
        max_response_tokens: int = 500
    ):
        """
        初始化客服机器人

        Args:
            client: OpenAIClient实例
            knowledge_base: 知识库列表
            max_response_tokens: 最大回复token数
        """
        self.client = client
        self.conversation_manager = ConversationManager(knowledge_base)
        self.max_response_tokens = max_response_tokens

    def start_conversation(self, user_id: str, metadata: Dict = None) -> str:
        """开始新会话"""
        return self.conversation_manager.create_conversation(user_id, metadata)

    def chat(
        self, 
        conversation_id: str, 
        user_message: str,
        temperature: float = 0.7
    ) -> Dict:
        """
        处理用户消息并生成回复

        Args:
            conversation_id: 会话ID
            user_message: 用户消息
            temperature: 生成随机性

        Returns:
            包含回复和元数据的字典
        """
        # 添加用户消息
        self.conversation_manager.add_message(
            conversation_id, 
            "user", 
            user_message
        )

        # 准备API调用
        messages = self.conversation_manager.format_messages_for_api(
            conversation_id
        )

        # 调用API
        try:
            response = self.client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=messages,
                max_tokens=self.max_response_tokens,
                temperature=temperature
            )

            assistant_message = response.choices[0].message.content

        except Exception as e:
            assistant_message = f"抱歉，系统遇到了问题: {str(e)}"

        # 添加助手回复
        self.conversation_manager.add_message(
            conversation_id,
            "assistant",
            assistant_message
        )

        return {
            "conversation_id": conversation_id,
            "user_message": user_message,
            "assistant_message": assistant_message,
            "timestamp": datetime.now().isoformat()
        }

    def get_conversation_history(self, conversation_id: str) -> List[Dict]:
        """获取会话历史"""
        return self.conversation_manager.get_messages(conversation_id)

    def clear_conversation(self, conversation_id: str):
        """清除会话"""
        self.conversation_manager.clear_conversation(conversation_id)

# customer_service_demo.py
# 客服机器人演示程序

from open_generative_ai import OpenAIClient
from conversation_manager import CustomerServiceBot

# 定义知识库
KNOWLEDGE_BASE = [
    {
        "question": "你们的工作时间是几点？",
        "answer": "我们的工作时间是为周一到周五的上午9点到下午6点，节假日除外。"
    },
    {
        "question": "如何重置密码？",
        "answer": "您可以通过以下步骤重置密码：1. 点击登录页面的'忘记密码'链接 2. 输入您注册的邮箱地址 3. 查收邮件并点击重置链接 4. 设置新密码。如果有任何问题，可以联系我们的客服。"
    },
    {
        "question": "如何联系人工客服？",
        "answer": "您可以通过以下方式联系人工客服：1. 拨打客服热线：400-123-4567 2. 发送邮件到 support@example.com 3. 在APP内点击'在线客服'按钮。我们的客服人员会在工作时间内尽快回复您。"
    },
    {
        "question": "产品支持哪些支付方式？",
        "answer": "我们支持多种支付方式，包括：1. 微信支付 2. 支付宝 3. 银行卡支付 4. Apple Pay（仅限iOS用户）。所有支付都经过加密处理，保障您的资金安全。"
    },
    {
        "question": "退款政策是什么？",
        "answer": "我们的退款政策如下：1. 购买后7天内，如对产品不满意，可以申请全额退款 2. 购买后7-30天，可以申请部分退款（扣除已使用天数费用）3. 超过30天后，不接受退款申请，但可以申请换货。退款将在1-3个工作日内原路返回。"
    },
    {
        "question": "会员有哪些等级？",
        "answer": "我们的会员分为四个等级：1. 免费会员：基础功能 2. 银卡会员：月费29元，享受9折优惠 3. 金卡会员：月费59元，享受8折优惠和专属客服 4. 钻石会员：月费99元，享受7折优惠，专属客服和优先体验新功能。"
    }
]

def run_demo():
    """运行演示"""
    print("=" * 60)
    print("智能客服机器人演示")
    print("=" * 60)

    # 初始化
    client = OpenAIClient(api_base="http://localhost:8000")
    bot = CustomerServiceBot(
        client=client,
        knowledge_base=KNOWLEDGE_BASE,
        max_response_tokens=500
    )

    # 开始会话
    user_id = "demo_user_001"
    conversation_id = bot.start_conversation(
        user_id=user_id,
        metadata={"source": "demo", "version": "1.0"}
    )

    print(f"\n会话已创建，会话ID: {conversation_id}")
    print("\n提示: 输入'quit'退出，输入'clear'清空对话历史\n")

    # 欢迎消息
    welcome = bot.chat(conversation_id, "你好，我想了解一下你们的服务")
    print(f"\n客服: {welcome['assistant_message']}\n")

    # 对话循环
    while True:
        try:
            user_input = input("用户: ").strip()
        except (KeyboardInterrupt, EOFError):
            print("\n\n再见!")
            break

        if user_input.lower() in ['quit', 'exit', '退出']:
            print("\n感谢您的咨询，再见!")
            break

        if user_input.lower() == 'clear':
            bot.clear_conversation(conversation_id)
            print("对话历史已清空\n")
            continue

        if not user_input:
            continue

        # 获取回复
        response = bot.chat(conversation_id, user_input)
        print(f"\n客服: {response['assistant_message']}\n")


if __name__ == "__main__":
    run_demo()

# writing_assistant.py
# AI写作助手

import re
from typing import List, Dict, Optional, Tuple
from enum import Enum
from dataclasses import dataclass

class WritingStyle(Enum):
    """写作风格枚举"""
    FORMAL = "formal"           # 正式
    CASUAL = "casual"           # 随意
    PROFESSIONAL = "professional"  # 专业
    CREATIVE = "creative"       # 创意
    ACADEMIC = "academic"       # 学术
    NEWS = "news"               # 新闻

class WritingLength(Enum):
    """写作长度枚举"""
    SHORT = "short"      # 短（100-200字）
    MEDIUM = "medium"    # 中（300-500字）
    LONG = "long"        # 长（800-1000字）

@dataclass
class WritingRequest:
    """写作请求"""
    task: str                    # 写作任务
    topic: str                   # 主题
    style: WritingStyle          # 风格
    length: WritingLength        # 长度
    keywords: List[str]         # 关键词
    audience: str               # 目标受众
    tone: str                   # 语气
    include_outline: bool        # 是否包含大纲
    language: str               # 语言

class WritingAssistant:
    """写作助手类"""

    def __init__(self, client):
        """
        初始化写作助手

        Args:
            client: OpenAIClient实例
        """
        self.client = client

    def generate_system_prompt(self, request: WritingRequest) -> str:
        """生成系统提示词"""
        style_descriptions = {
            WritingStyle.FORMAL: "正式、严谨的语言风格",
            WritingStyle.CASUAL: "轻松、亲切的语言风格",
            WritingStyle.PROFESSIONAL: "专业、权威的语言风格",
            WritingStyle.CREATIVE: "富有创意、想象力丰富的语言风格",
            WritingStyle.ACADEMIC: "学术、客观的语言风格",
            WritingStyle.NEWS: "新闻报道式的语言风格"
        }

        length_descriptions = {
            WritingLength.SHORT: "简短精炼（100-200字）",
            WritingLength.MEDIUM: "适中（300-500字）",
            WritingLength.LONG: "详细深入（800-1000字）"
        }

        prompt = f"""你是一位专业的内容创作专家，擅长各类写作任务。

## 写作任务
{request.task}

## 主题
{request.topic}

## 写作风格
{style_descriptions.get(request.style, '默认风格')}

## 目标受众
{request.audience}

## 语气
{request.tone}

## 文章长度
{length_descriptions.get(request.length, '默认长度')}"""

        if request.keywords:
            prompt += f"\n\n## 必须包含的关键词\n{', '.join(request.keywords)}"

        if request.include_outline:
            prompt += "\n\n## 要求\n1. 先提供文章大纲\n2. 然后按大纲撰写完整文章"
        else:
            prompt += "\n\n## 要求\n直接撰写完整文章，结构清晰，段落分明"

        return prompt

    def write_article(self, request: WritingRequest) -> Dict:
        """
        撰写文章

        Args:
            request: 写作请求

        Returns:
            包含文章内容和元数据的字典
        """
        system_prompt = self.generate_system_prompt(request)

        user_prompt = f"请撰写一篇文章。主题：{request.topic}"

        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_prompt}
            ],
            max_tokens=2000,
            temperature=0.8
        )

        result = response.choices[0].message.content

        return {
            "article": result,
            "outline": self.extract_outline(result) if request.include_outline else None,
            "metadata": {
                "task": request.task,
                "topic": request.topic,
                "style": request.style.value,
                "length": request.length.value,
                "keywords": request.keywords
            }
        }

    def extract_outline(self, text: str) -> Optional[List[str]]:
        """从文章中提取大纲"""
        lines = text.split('\n')
        outline = []

        for line in lines:
            # 匹配大纲格式（一、二、三 或 1. 2. 3. 或 ## 标题）
            if re.match(r'^[一二三四五六七八九十]+[、.．]', line.strip()):
                outline.append(line.strip())
            elif re.match(r'^##?\s+', line.strip()):
                outline.append(line.strip())

        return outline if outline else None

    def polish_text(
        self, 
        text: str, 
        style: WritingStyle,
        language: str = "zh"
    ) -> str:
        """
        润色文本

        Args:
            text: 待润色文本
            style: 目标风格
            language: 语言

        Returns:
            润色后的文本
        """
        style_prompts = {
            WritingStyle.FORMAL: "更加正式、严谨",
            WritingStyle.CASUAL: "更加轻松、亲切",
            WritingStyle.PROFESSIONAL: "更加专业、有深度",
            WritingStyle.CREATIVE: "更加生动、有创意"
        }

        system_prompt = f"""你是一位专业的内容编辑，擅长文本润色。
请将以下文本润色为{language}语言、{style_prompts.get(style, '更好')}的风格。

润色要求：
1. 保持原文的核心意思
2. 改善表达流畅度
3. 优化用词准确性
4. 调整句子结构使其更优美
5. 不要改变原文的基本立场和信息"""

        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": text}
            ],
            max_tokens=2000,
            temperature=0.7
        )

        return response.choices[0].message.content

    def expand_text(self, text: str, target_length: str = "medium") -> str:
        """
        扩展文本

        Args:
            text: 原文本
            target_length: 目标长度 (short/medium/long)

        Returns:
            扩展后的文本
        """
        length_descriptions = {
            "short": "扩展为200-300字",
            "medium": "扩展为500-800字",
            "long": "扩展为1500-2000字"
        }

        system_prompt = f"""你是一位专业的内容创作者。请将以下文本{length_descriptions.get(target_length, '扩展')}。

扩展要求：
1. 保持原文的核心观点和风格
2. 添加更多细节、例子和论证
3. 丰富表达方式，但不啰嗦
4. 确保新内容与原文逻辑连贯"""

        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": text}
            ],
            max_tokens=3000,
            temperature=0.7
        )

        return response.choices[0].message.content

    def summarize_text(self, text: str, length: str = "medium") -> str:
        """
        摘要文本

        Args:
            text: 原文
            length: 摘要长度 (short/medium/long)

        Returns:
            摘要文本
        """
        length_descriptions = {
            "short": "简短的摘要（50-100字）",
            "medium": "中等长度的摘要（200-300字）",
            "long": "详细的摘要（500-800字）"
        }

        system_prompt = f"""请为以下文本生成{length_descriptions.get(length, '摘要')}。

摘要要求：
1. 准确概括原文的核心观点
2. 保持原文的逻辑结构
3. 语言简洁明了
4. 突出重点信息"""

        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": text}
            ],
            max_tokens=1500,
            temperature=0.3
        )

        return response.choices[0].message.content

    def translate_text(
        self, 
        text: str, 
        target_language: str,
        preserve_format: bool = True
    ) -> str:
        """
        翻译文本

        Args:
            text: 原文
            target_language: 目标语言
            preserve_format: 是否保持格式

        Returns:
            翻译后的文本
        """
        format_instruction = "保持原有格式和段落结构" if preserve_format else ""

        system_prompt = f"""请将以下文本翻译成{target_language}。

翻译要求：
1. 准确传达原文意思
2. 符合目标语言的表达习惯
3. {format_instruction}
4. 适当处理文化差异"""

        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": text}
            ],
            max_tokens=3000,
            temperature=0.3
        )

        return response.choices[0].message.content

    def generate_title(
        self, 
        content: str, 
        style: str = "吸引眼球",
        count: int = 5
    ) -> List[str]:
        """
        生成标题

        Args:
            content: 内容摘要
            style: 标题风格
            count: 生成数量

        Returns:
            标题列表
        """
        system_prompt = f"""请根据以下内容生成{count}个{style}的标题。

标题要求：
1. 简洁有力，突出重点
2. 吸引读者注意力
3. 符合SEO优化要求
4. 每个标题不超过30个字

请按以下格式返回（每个标题一行）：
1. 标题1
2. 标题2
..."""

        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": content}
            ],
            max_tokens=500,
            temperature=0.8
        )

        titles = []
        for line in response.choices[0].message.content.split('\n'):
            line = line.strip()
            if line and (line[0].isdigit() or line.startswith('-')):
                # 去掉序号
                title = re.sub(r'^[0-9]+[.、)]\s*', '', line)
                titles.append(title)

        return titles


def writing_assistant_demo():
    """写作助手演示"""
    from open_generative_ai import OpenAIClient

    client = OpenAIClient(api_base="http://localhost:8000")
    assistant = WritingAssistant(client)

    print("=" * 60)
    print("AI写作助手演示")
    print("=" * 60)

    # 示例1：撰写文章
    print("\n【示例1：撰写文章】\n")

    request = WritingRequest(
        task="撰写一篇博客文章",
        topic="人工智能对未来教育的影响",
        style=WritingStyle.PROFESSIONAL,
        length=WritingLength.MEDIUM,
        keywords=["人工智能", "教育", "未来"],
        audience="普通读者",
        tone="客观中立",
        include_outline=True,
        language="zh"
    )

    result = assistant.write_article(request)
    print("文章大纲：")
    if result["outline"]:
        for item in result["outline"]:
            print(f"  {item}")
    print("\n文章内容：")
    print(result["article"])

    # 示例2：润色文本
    print("\n" + "-" * 40)
    print("【示例2：润色文本】\n")

    original = "人工智能技术发展很快，已经影响了很多行业。我觉得未来会有更多的变化。"
    polished = assistant.polish_text(original, WritingStyle.PROFESSIONAL)
    print(f"原文：{original}")
    print(f"润色后：{polished}")

    # 示例3：生成标题
    print("\n" + "-" * 40)
    print("【示例3：生成标题】\n")

    content = "探讨人工智能如何改变传统教育模式，包括个性化学习、智能辅导等方面的发展趋势。"
    titles = assistant.generate_title(content, count=5)
    print("生成的文章标题：")
    for i, title in enumerate(titles, 1):
        print(f"  {i}. {title}")


if __name__ == "__main__":
    writing_assistant_demo()

# 营销文案生成示例
def generate_marketing_copy(client, product_info: Dict, platform: str) -> str:
    """为不同平台生成营销文案"""

    prompts = {
        "weibo": """为以下产品生成一条微博风格的推广文案（不超过140字）：
产品：{name}
特点：{features}
卖点：{selling_point}""",
        "xiaohongshu": """为以下产品生成小红书风格的种草文案：
产品：{name}
特点：{features}
卖点：{selling_point}

要求：轻松亲切的语气，适合小红书平台风格""",
        "email": """为以下产品生成邮件营销文案：
产品：{name}
特点：{features}
卖点：{selling_point}

要求：专业但有吸引力，包含明确的行动号召"""
    }

    prompt_template = prompts.get(platform, prompts["email"])
    prompt = prompt_template.format(**product_info)

    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "你是一位经验丰富的营销文案专家。"},
            {"role": "user", "content": prompt}
        ],
        max_tokens=500,
        temperature=0.8
    )

    return response.choices[0].message.content

# 使用示例
product_info = {
    "name": "智能空气净化器 Pro",
    "features": "HEPA滤网、静音设计、智能感应",
    "selling_point": "守护家人呼吸健康"
}

weibo_copy = generate_marketing_copy(client, product_info, "weibo")
print(weibo_copy)

# 智能问答系统示例
class SmartQASystem:
    """智能问答系统"""

    def __init__(self, client):
        self.client = client
        self.qa_pairs = []
        self.documents = []

    def add_qa_pairs(self, qa_pairs: List[Dict]):
        """添加问答对"""
        self.qa_pairs.extend(qa_pairs)

    def find_best_match(self, question: str) -> Optional[Dict]:
        """找到最佳匹配的问答对"""
        question_embedding = self.client.embeddings.create(
            input=question,
            model="text-embedding-ada-002"
        ).data[0].embedding

        best_match = None
        best_score = 0

        for qa in self.qa_pairs:
            q_embedding = self.client.embeddings.create(
                input=qa["question"],
                model="text-embedding-ada-002"
            ).data[0].embedding

            score = cosine_similarity(question_embedding, q_embedding)
            if score > best_score:
                best_score = score
                best_match = qa

        return best_match if best_score > 0.7 else None

    def answer(self, question: str) -> str:
        """回答问题"""
        # 首先尝试精确匹配
        match = self.find_best_match(question)

        if match:
            return match["answer"]

        # 如果没有匹配，使用生成式回答
        context = self._build_context()
        prompt = f"""基于以下信息回答用户的问题。如果现有信息无法回答，请说明。

{context}

用户问题：{question}

回答要求：简洁、准确、有帮助"""

        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "你是一个乐于助人的问答助手。"},
                {"role": "user", "content": prompt}
            ],
            max_tokens=300
        )

        return response.choices[0].message.content

# 文本分析工具
class TextAnalyzer:
    """文本分析工具"""

    def __init__(self, client):
        self.client = client

    def analyze_sentiment(self, text: str) -> Dict:
        """情感分析"""
        prompt = f"""请分析以下文本的情感倾向，并给出评分。

文本：{text}

请按以下JSON格式返回结果（只返回JSON，不要其他内容）：
{{
    "sentiment": "positive/negative/neutral",
    "score": -1到1之间的数值，
    "emotion": "主要情感类型",
    "confidence": 置信度0到1
}}"""

        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "你是一个专业的情感分析专家。"},
                {"role": "user", "content": prompt}
            ],
            max_tokens=200,
            temperature=0.1
        )

        import json
        try:
            return json.loads(response.choices[0].message.content)
        except:
            return {"error": "解析失败"}

    def extract_keywords(self, text: str, top_n: int = 10) -> List[str]:
        """关键词提取"""
        prompt = f"""请从以下文本中提取{top_n}个最重要的关键词。

文本：{text}

请按重要性从高到低排列，以JSON数组格式返回：
["关键词1", "关键词2", ...]"""

        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "你是一个专业的关键词提取专家。"},
                {"role": "user", "content": prompt}
            ],
            max_tokens=200,
            temperature=0.1
        )

        import json
        try:
            return json.loads(response.choices[0].message.content)
        except:
            return []

    def summarize(self, text: str, max_length: int = 200) -> str:
        """文本摘要"""
        prompt = f"""请为以下文本生成一个简洁的摘要，控制在{max_length}字以内。

文本：{text}

摘要要求：
1. 概括核心观点
2. 语言简洁
3. 保留关键信息"""

        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "你是一个专业的文本摘要专家。"},
                {"role": "user", "content": prompt}
            ],
            max_tokens=500,
            temperature=0.3
        )

        return response.choices[0].message.content

    def classify_text(self, text: str, categories: List[str]) -> Dict:
        """文本分类"""
        categories_str = "、".join(categories)

        prompt = f"""请将以下文本分类到最合适的类别中。

文本：{text}

可选类别：{categories_str}

请按以下JSON格式返回：
{{
    "category": "分类结果",
    "confidence": 置信度0到1
}}"""

        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "你是一个专业的文本分类专家。"},
                {"role": "user", "content": prompt}
            ],
            max_tokens=200,
            temperature=0.1
        )

        import json
        try:
            return json.loads(response.choices[0].message.content)
        except:
            return {"error": "分类失败"}

# 代码辅助工具
class CodeAssistant:
    """代码辅助工具"""

    def __init__(self, client):
        self.client = client

    def generate_code(
        self, 
        description: str, 
        language: str = "python",
        style: str = "clean"
    ) -> str:
        """生成代码"""
        prompt = f"""请用{language}语言实现以下功能。

功能描述：{description}

代码要求：
1. 代码风格：{style}
2. 添加必要的注释
3. 考虑错误处理
4. 遵循最佳实践"""

        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "你是一个经验丰富的程序员。"},
                {"role": "user", "content": prompt}
            ],
            max_tokens=1500,
            temperature=0.3
        )

        return response.choices[0].message.content

    def explain_code(self, code: str) -> str:
        """解释代码"""
        prompt = f"""请解释以下代码的功能和工作原理。

代码：
```python
{code}

    response = self.client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "你是一个耐心的编程导师。"},
            {"role": "user", "content": prompt}
        ],
        max_tokens=1000,
        temperature=0.3
    )

    return response.choices[0].message.content

def debug_code(self, code: str, error: str = None) -> str:
    """调试代码"""
    if error:
        prompt = f"""请帮助调试以下代码，发现并修复其中的错误。