从0到跑通业务（应该能吧）

# ========== Node.js 安装（任选一种）==========

# 方式A：nvm（推荐，版本切换方便）
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.0/install.sh | bash
nvm install 20
nvm use 20
node -v  # 确认输出 v20.x.x

# 方式B：直接下载（Windows去 nodejs.org 下载 MSI）
# Linux 一键
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash - && sudo apt-get install -y nodejs
node -v && npm -v

# ========== Python 安装（任选一种）==========

# 方式A：Miniconda（推荐，隔离性好）
# 下载：https://docs.anaconda.com/miniconda/
# Linux:
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh
# 安装时选"yes"自动加入 PATH

# 方式B：系统 Python + venv
sudo apt update && sudo apt install python3.11 python3.11-venv python3-pip
python3.11 -m venv ai-env
source ai-env/bin/activate

# 验证
python --version  # 确认输出 Python 3.10+ 或 3.11+ 或 3.12+
pip --version

# ========== pip 镜像源配置 ==========

# 临时使用（每次命令后跟 -i）
pip install requests -i https://pypi.tuna.tsinghua.edu.cn/simple

# 永久配置
mkdir -p ~/.pip
cat > ~/.pip/pip.conf << 'EOF'
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host = pypi.tuna.tsinghua.edu.cn
EOF

# 验证
pip config list

# ========== npm 镜像源配置 ==========

# 查看当前源
npm config get registry

# 临时使用
npm install express -g --registry=https://registry.npmmirror.com

# 永久配置为淘宝镜像
npm config set registry https://registry.npmmirror.com

# 验证
npm config get registry  # 应输出 https://registry.npmmirror.com

# ========== 环境变量配置 ==========

# Linux/Mac：将以下写入 ~/.bashrc 或 ~/.zshrc
# Windows：用系统属性 -> 环境变量 GUI界面

# ==== 方式A：.env 文件（项目内，推荐） ====
# 项目根目录创建 .env 文件（加入 .gitignore！）
cat > .env << 'EOF'
# 大模型 API Keys（去对应平台申请）
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxx
DASHSCOPE_API_KEY=sk-xxxxxxxxxxxxxxxx
# 代理（如需要）
HTTP_PROXY=http://127.0.0.1:7890
HTTPS_PROXY=http://127.0.0.1:7890
EOF

# ==== 方式B：系统环境变量（全局） ====
# Linux/Mac 永久生效：
echo 'export OPENAI_API_KEY="sk-xxxxx"' >> ~/.bashrc
echo 'export DASHSCOPE_API_KEY="sk-xxxxx"' >> ~/.bashrc
source ~/.bashrc

# 验证环境变量是否生效
echo $OPENAI_API_KEY  # 应输出 sk-xxxxx（不要泄露！）
python -c "import os; print(os.environ.get('OPENAI_API_KEY','未设置'))"

# ========== 一键安装脚本 ==========

# --- Node.js 项目 ---
cat > install-node.sh << 'EOF'
#!/bin/bash
set -e
echo "安装 Node.js 依赖..."
npm install
echo "✅ Node.js 依赖安装完成"
npm --version
node --version
EOF
chmod +x install-node.sh
./install-node.sh

# --- Python 项目 ---
cat > install-python.sh << 'EOF'
#!/bin/bash
set -e
echo "安装 Python 依赖..."
pip install --upgrade pip
pip install requests openai python-dotenv tqdm
echo "✅ Python 依赖安装完成"
pip --version
python --version
EOF
chmod +x install-python.sh
./install-python.sh

// ========== 方案A：Vite 代理（推荐） ==========
// vite.config.js
import { defineConfig } from 'vite'

export default defineConfig({
  server: {
    port: 3000,               // 本地端口
    proxy: {
      // /api/proxy -> https://api.openai.com（不发OPTIONS预检）
      '/api/proxy': {
        target: 'https://api.openai.com',
        changeOrigin: true,
        rewrite: (path) => path.replace(/^\/api\/proxy/, ''),
      },
      // /api/proxy-dashscope -> https://dashscope.aliyuncs.com
      '/api/proxy-dashscope': {
        target: 'https://dashscope.aliyuncs.com',
        changeOrigin: true,
        rewrite: (path) => path.replace(/^\/api\/proxy-dashscope/, ''),
      }
    }
  }
})

// 使用时：
// fetch('/api/proxy/v1/chat/completions', ...)  // 浏览器只发一次请求到本服务器

{
  "model": "gpt-4o-mini",              // 模型名称（必填）
  "messages": [                        // 对话历史（必填）
    {"role": "system",      "content": "你是一个专业的Python后端工程师"}, // 系统指令
    {"role": "user",        "content": "解释一下闭包"},                    // 用户问题
    {"role": "assistant",   "content": "闭包是..."},                      // AI历史（可选）
    {"role": "user",        "content": "那装饰器呢"}                      // 追问
  ],
  "max_tokens": 1000,                  // 最大生成token
  "temperature": 0.7,                  // 创造性（0-2）
  "top_p": 1.0,                        // 核采样（通常不调）
  "frequency_penalty": 0,             // 重复惩罚（0-2）
  "presence_penalty": 0,              // 话题新鲜度（-2到2）
  "stream": false,                     // 是否流式
  "stop": null,                        // 停止序列
  "seed": null                         // 随机种子（temperature=0时生效）
}

// ========== 响应结构 ==========
{
  "id": "chatcmpl-xxx",
  "object": "chat.completion",
  "created": 1710000000,
  "model": "gpt-4o-mini",
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "闭包是指..."
    },
    "finish_reason": "stop",    // stop | length | content_filter
    "logprobs": null
  }],
  "usage": {
    "prompt_tokens": 50,         // 输入消耗
    "completion_tokens": 120,    // 输出消耗
    "total_tokens": 170          // 总消耗
  }
}

// ========== 流式响应 chunks ==========
{"id":"xxx","choices":[{"delta":{"content":"闭"},"finish_reason":null}]}
{"id":"xxx","choices":[{"delta":{"content":"包"},"finish_reason":null}]}
{"id":"xxx","choices":[{"delta":{"content":"是"},"finish_reason":null}]}
...
{"id":"xxx","choices":[{"delta":{},"finish_reason":"stop"}]}

// ========== 文件：openai_basic.mjs ==========
// 运行：node openai_basic.mjs
// 注意：需要设置环境变量 OPENAI_API_KEY

const API_KEY = process.env.OPENAI_API_KEY;
const API_URL = 'https://api.openai.com/v1/chat/completions';

async function callOpenAI(userMessage) {
  const response = await fetch(API_URL, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${API_KEY}`,
    },
    body: JSON.stringify({
      model: 'gpt-4o-mini',          // 模型名称
      messages: [
        { role: 'user', content: userMessage }
      ],
      max_tokens: 500,
      temperature: 0.7,
    }),
  });

  // 检查HTTP状态码
  if (!response.ok) {
    const error = await response.text();
    throw new Error(`API错误 ${response.status}: ${error}`);
  }

  const data = await response.json();
  return data.choices[0].message.content;
}

// 调用示例
(async () => {
  try {
    const reply = await callOpenAI('用一句话介绍Python');
    console.log('AI回复:', reply);
  } catch (e) {
    console.error('调用失败:', e.message);
  }
})();

# ========== 文件：openai_basic.py ==========
# 运行：python openai_basic.py
# 依赖：pip install requests
# 环境变量：export OPENAI_API_KEY=sk-xxx

import os
import requests

API_KEY = os.environ.get('OPENAI_API_KEY')
API_URL = 'https://api.openai.com/v1/chat/completions'

def call_openai(user_message: str) -> str:
    """调用 OpenAI ChatGPT，返回 AI 回复文本"""
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {API_KEY}',
    }
    payload = {
        'model': 'gpt-4o-mini',
        'messages': [
            {'role': 'user', 'content': user_message}
        ],
        'max_tokens': 500,
        'temperature': 0.7,
    }

    response = requests.post(API_URL, headers=headers, json=payload, timeout=30)
    response.raise_for_status()  # HTTP错误时抛出异常

    data = response.json()
    return data['choices'][0]['message']['content']

# 调用示例
if __name__ == '__main__':
    try:
        reply = call_openai('用一句话介绍Python')
        print(f'AI回复: {reply}')
    except Exception as e:
        print(f'调用失败: {e}')

# ========== 文件：dashscope_basic.py ==========
# 运行：python dashscope_basic.py
# 依赖：pip install requests
# 环境变量：export DASHSCOPE_API_KEY=sk-xxx
# 模型列表：https://help.aliyun.com/zh/model-studio/getting-started/models

import os
import requests

API_KEY = os.environ.get('DASHSCOPE_API_KEY')
# DashScope 使用与 OpenAI 兼容的接口格式
API_URL = 'https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions'

def call_dashscope(user_message: str, model: str = 'qwen-plus') -> str:
    """调用阿里云 DashScope 大模型"""
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {API_KEY}',
    }
    payload = {
        'model': model,  # 可选：qwen-plus, qwen-turbo, qwen-max, qwen-long
        'messages': [
            {'role': 'user', 'content': user_message}
        ],
        'max_tokens': 500,
        'temperature': 0.7,
    }

    response = requests.post(API_URL, headers=headers, json=payload, timeout=30)
    response.raise_for_status()

    data = response.json()
    return data['choices'][0]['message']['content']

if __name__ == '__main__':
    try:
        reply = call_dashscope('用一句话介绍Python', model='qwen-plus')
        print(f'AI回复: {reply}')
    except Exception as e:
        print(f'调用失败: {e}')

# ========== 文件：llm_client.py ==========
# 运行：python llm_client.py
# 依赖：pip install openai python-dotenv

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()  # 加载 .env 文件中的环境变量

class LLMClient:
    """统一的大模型调用封装"""

    def __init__(self, provider='openai'):
        self.provider = provider
        if provider == 'openai':
            self.client = OpenAI(api_key=os.environ.get('OPENAI_API_KEY'))
            self.default_model = 'gpt-4o-mini'
        elif provider == 'dashscope':
            # DashScope 使用 OpenAI 兼容接口
            self.client = OpenAI(
                api_key=os.environ.get('DASHSCOPE_API_KEY'),
                base_url='https://dashscope.aliyuncs.com/compatible-mode/v1'
            )
            self.default_model = 'qwen-plus'
        else:
            raise ValueError(f'未知的 provider: {provider}')

    def chat(self, message: str, model: str = None, temperature: float = 0.7, max_tokens: int = 500) -> str:
        """发送对话请求，返回 AI 回复"""
        model = model or self.default_model
        response = self.client.chat.completions.create(
            model=model,
            messages=[{'role': 'user', 'content': message}],
            temperature=temperature,
            max_tokens=max_tokens,
        )
        return response.choices[0].message.content

    def chat_with_context(self, messages: list, model: str = None, temperature: float = 0.7) -> str:
        """带上下文的对话（支持多轮）"""
        model = model or self.default_model
        response = self.client.chat.completions.create(
            model=model,
            messages=messages,
            temperature=temperature,
        )
        return response.choices[0].message.content

# 使用示例
if __name__ == '__main__':
    # OpenAI
    client = LLMClient(provider='openai')
    reply = client.chat('用一句话介绍Python')
    print(f'OpenAI: {reply}')

    # 阿里云 DashScope
    ds_client = LLMClient(provider='dashscope')
    reply = ds_client.chat('用一句话介绍JavaScript')
    print(f'DashScope: {reply}')

// ========== 文件：llm_client.mjs ==========
// 运行：node llm_client.mjs
// 依赖：npm install openai
// 环境变量：export OPENAI_API_KEY=sk-xxx

import OpenAI from 'openai';

class LLMClient {
  constructor(provider = 'openai') {
    this.provider = provider;
    if (provider === 'openai') {
      this.client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
      this.defaultModel = 'gpt-4o-mini';
    } else if (provider === 'dashscope') {
      this.client = new OpenAI({
        apiKey: process.env.DASHSCOPE_API_KEY,
        baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1'
      });
      this.defaultModel = 'qwen-plus';
    }
  }

  async chat(message, { model, temperature = 0.7, maxTokens = 500 } = {}) {
    const response = await this.client.chat.completions.create({
      model: model || this.defaultModel,
      messages: [{ role: 'user', content: message }],
      temperature,
      max_tokens: maxTokens,
    });
    return response.choices[0].message.content;
  }

  async chatWithContext(messages, { model, temperature = 0.7 } = {}) {
    const response = await this.client.chat.completions.create({
      model: model || this.defaultModel,
      messages,
      temperature,
    });
    return response.choices[0].message.content;
  }
}

// 使用示例
const client = new LLMClient('openai');
const reply = await client.chat('用一句话介绍Python');
console.log('OpenAI:', reply);

# ========== 文件：unified_llm.py ==========
# 运行：python unified_llm.py
# 依赖：pip install openai python-dotenv

import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

class UnifiedLLM:
    """统一调用入口，一个函数适配所有模型"""

    # 模型配置表：可按需添加新模型
    PROVIDERS = {
        'gpt4o': {
            'client': OpenAI(api_key=os.environ.get('OPENAI_API_KEY')),
            'model': 'gpt-4o',
            'base_url': None,
        },
        'gpt4o-mini': {
            'client': OpenAI(api_key=os.environ.get('OPENAI_API_KEY')),
            'model': 'gpt-4o-mini',
            'base_url': None,
        },
        'qwen-plus': {
            'client': OpenAI(
                api_key=os.environ.get('DASHSCOPE_API_KEY'),
                base_url='https://dashscope.aliyuncs.com/compatible-mode/v1'
            ),
            'model': 'qwen-plus',
            'base_url': 'dashscope',
        },
        'siliconflow': {
            'client': OpenAI(
                api_key=os.environ.get('SILICONFLOW_API_KEY'),
                base_url='https://api.siliconflow.cn/v1'
            ),
            'model': 'Qwen/Qwen2.5-7B-Instruct',
            'base_url': 'siliconflow',
        },
    }

    def __init__(self, provider_key='gpt4o-mini'):
        cfg = self.PROVIDERS.get(provider_key)
        if not cfg:
            raise ValueError(f'未知 provider: {provider_key}，可用: {list(self.PROVIDERS.keys())}')
        self.client = cfg['client']
        self.model = cfg['model']

    def ask(self, prompt: str, temperature: float = 0.7, max_tokens: int = 1000) -> str:
        """同步调用，返回字符串"""
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[{'role': 'user', 'content': prompt}],
            temperature=temperature,
            max_tokens=max_tokens,
        )
        return response.choices[0].message.content

    def ask_stream(self, prompt: str, temperature: float = 0.7):
        """流式调用，返回生成器"""
        stream = self.client.chat.completions.create(
            model=self.model,
            messages=[{'role': 'user', 'content': prompt}],
            temperature=temperature,
            stream=True,
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield chunk.choices[0].delta.content

# 使用示例
if __name__ == '__main__':
    # 切换模型只需改这一行
    llm = UnifiedLLM('qwen-plus')  # 试试 'gpt4o-mini' 或 'siliconflow'

    # 同步调用
    reply = llm.ask('Python和JavaScript的区别是什么？')
    print(f'回复: {reply}')

    # 流式调用
    print('\n流式输出: ', end='')
    for text in llm.ask_stream('用3句话介绍Go语言'):
        print(text, end='', flush=True)
    print()

# ========== 文件：chat_with_memory.py ==========
# 运行：python chat_with_memory.py

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.environ.get('OPENAI_API_KEY'))

def chat_with_memory(user_input: str, history: list[dict]) -> tuple[str, list[dict]]:
    """
    带记忆的对话
    返回: (AI回复, 更新后的历史)
    """
    # 将用户新输入追加到历史
    history.append({'role': 'user', 'content': user_input})

    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=history,
        temperature=0.7,
    )

    assistant_msg = response.choices[0].message.content
    history.append({'role': 'assistant', 'content': assistant_msg})

    return assistant_msg, history

# 使用示例
if __name__ == '__main__':
    # 初始化对话历史（可加系统指令）
    messages = [
        {'role': 'system', 'content': '你是一个专业Python讲师，用简洁有趣的方式教学。'}
    ]

    # 第1轮
    reply1, messages = chat_with_memory('Python适合初学者吗？', messages)
    print(f'AI: {reply1}\n')

    # 第2轮（带历史）
    reply2, messages = chat_with_memory('那Java呢？', messages)
    print(f'AI: {reply2}\n')

    # 第3轮（模型知道前两轮内容）
    reply3, messages = chat_with_memory('它们两个学哪个好？', messages)
    print(f'AI: {reply3}')

    # 打印对话历史长度，确认上下文在累积
    print(f'\n当前对话历史：{len(messages)} 条消息')

# ========== 文件：stream_chat.py ==========
# 运行：python stream_chat.py

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.environ.get('OPENAI_API_KEY'))

def stream_chat(prompt: str):
    """流式调用，实时打印 AI 输出"""
    stream = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}],
        stream=True,  # 关键：stream=True
    )

    print('AI: ', end='', flush=True)
    full_reply = ''
    for chunk in stream:
        if chunk.choices[0].delta.content:
            text = chunk.choices[0].delta.content
            print(text, end='', flush=True)
            full_reply += text
    print()  # 换行
    return full_reply

# Node.js 版本：
# ========== 文件：stream_chat.mjs ==========
# const stream = await client.chat.completions.create({
#   model: 'gpt-4o-mini',
#   messages: [{ role: 'user', content: prompt }],
#   stream: true,
# });
# for await (const chunk of stream) {
#   process.stdout.write(chunk.choices[0].delta.content || '');
# }

if __name__ == '__main__':
    reply = stream_chat('写一首关于编程的小诗')

# ========== 文件：function_calling.py ==========
# 运行：python function_calling.py

import os
import json
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.environ.get('OPENAI_API_KEY'))

# 定义可用函数
functions = [
    {
        'type': 'function',
        'function': {
            'name': 'get_weather',
            'description': '查询城市天气',
            'parameters': {
                'type': 'object',
                'properties': {
                    'city': {'type': 'string', 'description': '城市名称'},
                    'unit': {'type': 'string', 'enum': ['celsius', 'fahrenheit'], 'description': '温度单位'}
                },
                'required': ['city']
            }
        }
    }
]

def get_weather(city: str, unit: str = 'celsius') -> dict:
    """模拟天气查询（真实项目里调用天气API）"""
    return {'city': city, 'temperature': 22, 'condition': '晴天', 'unit': unit}

# 用户提问
user_question = '北京今天多少度？'

response = client.chat.completions.create(
    model='gpt-4o-mini',
    messages=[{'role': 'user', 'content': user_question}],
    tools=functions,
)

assistant_msg = response.choices[0].message
print(f'AI回复内容: {assistant_msg.content}')
print(f'AI决定调用的工具: {assistant_msg.tool_calls}')

# 如果AI决定调用工具，执行函数
if assistant_msg.tool_calls:
    for tool_call in assistant_msg.tool_calls:
        fn_name = tool_call.function.name
        fn_args = json.loads(tool_call.function.arguments)
        print(f'\n执行函数: {fn_name}({fn_args})')

        if fn_name == 'get_weather':
            result = get_weather(**fn_args)
            print(f'函数返回: {result}')

            # 将工具结果反馈给AI，生成最终回复
            follow_up = client.chat.completions.create(
                model='gpt-4o-mini',
                messages=[
                    {'role': 'user', 'content': user_question},
                    assistant_msg,
                    {'role': 'tool', 'tool_call_id': tool_call.id, 'content': json.dumps(result)},
                ],
            )
            print(f'\n最终回复: {follow_up.choices[0].message.content}')

🤖 AI 问答助手


发送

# ========== 文件：batch_processor.py ==========
# 运行：python batch_processor.py
# 用途：批量将中文标题翻译成英文 / 提取摘要 / 分类
# 依赖：pip install openai python-dotenv tqdm

import os
from dotenv import load_dotenv
from openai import OpenAI
from tqdm import tqdm

load_dotenv()
client = OpenAI(api_key=os.environ.get('OPENAI_API_KEY'))

# ========== 示例任务 ==========
titles = [
    'Python入门完全指南',
    'JavaScript高级技巧分享',
    '深度学习中的正则化技术',
    'Web开发安全最佳实践',
    '机器学习模型评估指标详解',
]

def translate_to_english(text: str) -> str:
    """翻译成英文"""
    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{
            'role': 'user',
            'content': f'将以下中文标题翻译成英文，保持简洁：{text}'
        }],
        temperature=0.3,  # 翻译用低温度，保证一致性
        max_tokens=50,
    )
    return response.choices[0].message.content.strip()

def summarize(text: str) -> str:
    """生成一句话摘要"""
    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{
            'role': 'user',
            'content': f'为以下文本生成一句话中文摘要（不超过20字）：{text}'
        }],
        temperature=0.3,
        max_tokens=30,
    )
    return response.choices[0].message.content.strip()

# ========== 批量执行 ==========
if __name__ == '__main__':
    print('=== 批量翻译 ===')
    for title in tqdm(titles, desc='翻译中'):
        en_title = translate_to_english(title)
        print(f'{title} → {en_title}')

    print('\n=== 批量摘要 ===')
    for title in tqdm(titles, desc='摘要中'):
        summary = summarize(title)
        print(f'{title} → {summary}')

// ========== 文件：slack_bot.mjs ==========
// 运行：node slack_bot.mjs
// 依赖：npm install @slack/bolt openai
// 需配置 SLACK_BOT_TOKEN, SLACK_APP_TOKEN, OPENAI_API_KEY 环境变量

import { App } from '@slack/bolt';
import OpenAI from 'openai';

const app = new App({
  token: process.env.SLACK_BOT_TOKEN,
  signingSecret: process.env.SLACK_APP_SIGNING_SECRET,
});
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// 监听 DM 消息
app.message(/.*/, async ({ message, say }) => {
  if (message.subtype === 'bot_message') return; // 忽略机器人消息

  const userMessage = message.text;
  console.log(`收到消息 from ${message.user}: ${userMessage}`);

  // 调用 OpenAI
  const response = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [{ role: 'user', content: userMessage }],
    max_tokens: 500,
  });

  const reply = response.choices[0].message.content;
  await say(reply);  // 回复用户
});

(async () => {
  await app.start({ port: 3000 });
  console.log('🤖 Slack Bot 运行在 http://localhost:3000');
})();

# ========== 文件：requirements.txt ==========
# langchain==0.1.0
# langchain-community==0.0.10
# chromadb==0.4.22
# openai==1.10.0
# python-dotenv==1.0.0
# uvicorn==0.27.0

# ========== 文件：build_index.py（构建索引，一次性）==========
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

loader = TextLoader("knowledge.txt", encoding="utf-8")
docs = loader.load()

splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_documents(docs)

vectorstore = Chroma.from_documents(
    chunks, OpenAIEmbeddings(model="text-embedding-3-small"), persist_directory="./chroma_db"
)
vectorstore.persist()
print(f"✅ 索引构建完成，共 {len(chunks)} 个块")

# ========== 文件：app.py（FastAPI 服务）==========
from fastapi import FastAPI
from pydantic import BaseModel
from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

app = FastAPI(title="RAG 知识库问答 API")

embedding = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embedding)
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
qa_chain = RetrievalQA.from_chain_type(llm=llm, retriever=vectorstore.as_retriever(search_kwargs={"k": 3}))

class Question(BaseModel):
    query: str

@app.post("/ask")
def ask(question: Question):
    result = qa_chain.invoke({"query": question.query})
    return {"answer": result["result"], "sources": [doc.page_content[:100] for doc in result.get("source_documents", [])]}

# 运行：uvicorn app:app --reload --port 8000
# 测试：curl -X POST http://localhost:8000/ask -H "Content-Type: application/json" -d '{"query": "这份文档讲了什么？"}'

# ========== 文件：simple_agent.py ==========
# 运行：python simple_agent.py
# 依赖：pip install langchain langchain-openai duckduckgo-search

from langchain_agents import Agent
from langchain.tools import Tool
from langchain_community.utilities import DuckDuckGoSearchAPIWrapper
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, AgentType

# ========== 定义工具 ==========
search = DuckDuckGoSearchAPIWrapper()

def search_tool(query: str) -> str:
    """搜索工具"""
    return search.run(query)

tools = [
    Tool(name="搜索", func=search_tool, description="当需要查找实时信息时使用")
]

# ========== 初始化 Agent ==========
llm = ChatOpenAI(model="gpt-4o", temperature=0)
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,  # ReAct 模式
    verbose=True
)

# ========== 运行 ==========
task = "搜索苹果公司最新财报，分析其营收结构和增长趋势"
result = agent.run(task)
print(result)

# ========== 文件：lora_finetune.py ==========
# 运行：python lora_finetune.py
# 依赖：pip install torch transformers peft datasets trl python-dotenv accelerate

import os
import torch
from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    TrainingArguments,
    DataCollatorForSeq2Seq,
)
from peft import LoraConfig, get_peft_model, TaskType
from trl import SFTTrainer

# ========== 配置 ==========
MODEL_NAME = "Qwen/Qwen2.5-0.5B-Instruct"  # 7B 需要更多显存，0.5B 可在单卡跑
OUTPUT_DIR = "./lora_output"

# ========== 加载模型 ==========
model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
model.print_trainable_parameters()
# 预期输出：trainable params: XXXX || all params: XXXX || trainable%: 0.X%

# ========== 配置 LoRA ==========
lora_config = LoraConfig(
    r=16,                          # 秩，越大越强但越慢
    lora_alpha=32,                 # LoRA 缩放因子
    target_modules=[               # 应用到哪些层
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM,
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

# ========== 准备数据 ==========
# 格式：{"instruction": "...", "input": "...", "output": "..."}
def format_example(example):
    prompt = f"指令：{example['instruction']}\n"
    if example.get('input'):
        prompt += f"输入：{example['input']}\n"
    return {"text": prompt + f"回答：{example['output']}"}

dataset = load_dataset("json", data_files="train.jsonl", split="train")
dataset = dataset.map(format_example)

# ========== 训练 ==========
training_args = TrainingArguments(
    output_dir=OUTPUT_DIR,
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=1e-4,
    warmup_ratio=0.1,
    lr_scheduler_type="cosine",
    bf16=True,
    logging_steps=10,
    save_steps=500,
    report_to="tensorboard",
)

trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    data_collator=DataCollatorForSeq2Seq(tokenizer=tokenizer, model=model),
)

trainer.train()

# ========== 推理：合并 LoRA 到原模型 ==========
from peft import PeftModel
base_model = AutoModelForCausalLM.from_pretrained(MODEL_NAME, torch_dtype=torch.bfloat16)
merged_model = PeftModel.from_pretrained(base_model, OUTPUT_DIR).merge_and_unload()
merged_model.save_pretrained("./merged_model")
print("✅ 微调完成，模型已保存到 ./merged_model")

# ========== 安装 vLLM ==========
pip install vllm

# ========== 启动 vLLM 服务 ==========
# 单卡
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --port 8000 \
    --dtype half \
    --gpu-memory-utilization 0.9

# 多卡（Tensor Parallelism）
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --port 8000 \
    --tensor-parallel-size 2 \
    --dtype half

# ========== API 调用（与 OpenAI 兼容）==========
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen2.5-7B-Instruct",
    "messages": [{"role": "user", "content": "用一句话介绍Python"}],
    "max_tokens": 200,
    "temperature": 0.7
  }'

# ========== 安装 Ollama ==========
# Linux
curl -fsSL https://ollama.com/install.sh | sh

# ========== 拉取并运行模型 ==========
ollama pull qwen2.5:7b        # 下载模型（需要 4GB+ 磁盘）
ollama run qwen2.5:7b         # 交互式对话

# ========== API 服务（REST API）==========
# Ollama 自动在 11434 端口提供 REST API
curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5:7b",
  "messages": [{"role": "user", "content": "用一句话介绍Python"}],
  "stream": false
}'

# ========== Python 调用 ==========
# pip install ollama
import ollama
response = ollama.chat(
    model='qwen2.5:7b',
    messages=[{"role": "user", "content": "用一句话介绍Python"}]
)
print(response['message']['content'])

# ========== 模型管理 ==========
ollama list                   # 查看已下载模型
ollama rm qwen2.5:7b         # 删除模型
ollama show qwen2.5:7b        # 查看模型信息