传统方式：用多个工具拼凑，无法智能化联动
import os
import PyPDF2
from openai import OpenAI

client = OpenAI()

def read_pdf(filepath):
    with open(filepath, 'rb') as f:
        reader = PyPDF2.PdfReader(f)
        text = ''
        for page in reader.pages:
            text += page.extract_text()
    return text

def ask_gpt(prompt):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

 缺点1：硬编码流程，无法自适应变化
 缺点2：每次请求都走云端，延迟高、隐私风险大
 缺点3：无法自主决策——PDF多了怎么办？需要联网怎么办？

用户输入“帮我整理桌面文件”
        ↓
LLM理解意图 → 规划分解（步骤1：扫描目录；步骤2：分类文件；步骤3：生成报告）
        ↓
工具调用执行（调用文件系统API）
        ↓
观察执行结果 → 判断是否完成 → 未完成则调整策略继续
        ↓
返回最终结果

 1. 安装Ollama（MacOS/Linux/Windows均可）
curl -fsSL https://ollama.com/install.sh | sh

 2. 拉取本地模型（以Llama 3.2 3B为例，仅~2GB）
ollama pull llama3.2

 3. 安装Python依赖
pip install langchain langchain-community faiss-cpu streamlit pypdf

 local_ai_assistant.py
 功能：本地PC AI助手，支持文档问答 + Agent自主工具调用

import os
from langchain.llms import Ollama
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import FAISS
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType
from langchain.memory import ConversationBufferMemory

 ========== 配置本地模型 ==========
 使用Ollama本地运行LLM
llm = Ollama(
    model="llama3.2",   本地模型名称
    temperature=0.7,
    base_url="http://localhost:11434"
)

 嵌入模型（用于文档向量化）
embeddings = OllamaEmbeddings(model="llama3.2")

 ========== 构建本地知识库（RAG核心）==========
def build_local_knowledge_base(doc_path: str):
    """将本地文档构建为向量知识库"""
     加载PDF文档
    loader = PyPDFLoader(doc_path)
    documents = loader.load()
    
     文档切分（每块500字符，重叠50字符）
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,
        chunk_overlap=50
    )
    chunks = text_splitter.split_documents(documents)
    
     创建FAISS向量存储
    vectorstore = FAISS.from_documents(chunks, embeddings)
    return vectorstore

 ========== 定义Agent可用的工具 ==========
def search_knowledge(query: str) -> str:
    """工具1：从本地知识库检索相关信息"""
     假设已预先构建vectorstore
     此处为示例，实际使用时需要传入vectorstore
    docs = vectorstore.similarity_search(query, k=3)
    return "\n".join([doc.page_content for doc in docs])

def list_files(directory: str = ".") -> str:
    """工具2：列出指定目录下的文件"""
    try:
        files = os.listdir(directory)
        return f"目录下共有{len(files)}个文件：{', '.join(files[:10])}"
    except Exception as e:
        return f"读取失败：{str(e)}"

def file_reader(filepath: str) -> str:
    """工具3：读取文件内容（限制大小）"""
    try:
        if os.path.getsize(filepath) > 1024  1024:   限制1MB
            return "文件过大，仅显示前1000字符"
        with open(filepath, 'r', encoding='utf-8') as f:
            content = f.read(2000)   读取前2000字符
        return content
    except Exception as e:
        return f"读取失败：{str(e)}"

 注册工具集
tools = [
    Tool(name="KnowledgeBaseSearch", func=search_knowledge, 
         description="从本地知识库中相关文档内容"),
    Tool(name="ListFiles", func=list_files,
         description="列出指定目录下的文件，参数为目录路径"),
    Tool(name="ReadFile", func=file_reader,
         description="读取文件内容，参数为文件路径")
]

 ========== 初始化Agent（带记忆）==========
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory,
    verbose=True,   打印Agent思考过程
    handle_parsing_errors=True
)

 ========== 运行示例 ==========
if __name__ == "__main__":
     构建知识库（首次运行）
     vectorstore = build_local_knowledge_base("./docs/technical_manual.pdf")
    
    print("🤖 本地PC AI助手已启动（按Ctrl+C退出）")
    while True:
        user_input = input("\n你：")
        if user_input.lower() in ['exit', 'quit']:
            break
        
         Agent自主决策并执行
        response = agent.run(user_input)
        print(f"AI助手：{response}")

用户：帮我从文档中找“NPU性能参数”，然后把结果保存到文件

Agent内部循环：
┌─────────────────────────────────────────────────┐
│ Step 1 - 思考（Thought）:                       │
│   “用户需要知识库，然后保存结果到文件”          │
│ Step 2 - 行动（Action）:                        │
│   调用 KnowledgeBaseSearch("NPU性能参数")         │
│ Step 3 - 观察（Observation）:                    │
│   返回结果：“NPU算力50 TOPS，支持FP8...”          │
│ Step 4 - 继续推理（Thought）:                    │
│   “已获取内容，下一步调用WriteFile保存”            │
│ Step 5 - 执行写入并返回最终结果                  │
└─────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│                    PC AI 助手应用层                      │
│     (文档处理 | 代码辅助 | 邮件管理 | 浏览器自动化)        │
├─────────────────────────────────────────────────────────┤
│                    Agent 编排层                          │
│  规划(Planner) | 执行(Executor) | 反思(Reflector)       │
├─────────────────────────────────────────────────────────┤
│                    记忆与工具层                           │
│  短期记忆 | 长期记忆(向量库) | 工具集(Tools + MCP)        │
├─────────────────────────────────────────────────────────┤
│                    模型推理层                            │
│  端侧LLM (7B~20B) | 嵌入模型 | 量化/压缩                 │
├─────────────────────────────────────────────────────────┤
│                    硬件加速层                            │
│  NPU (AI推理) | GPU (并行计算) | CPU (通用逻辑)          │
│        统一内存架构 | 异构调度 | 能效优化                 │
└─────────────────────────────────────────────────────────┘