# 01-langchain

**Repository Path**: itluma2008/01-langchain

## Basic Information

- **Project Name**: 01-langchain
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 2
- **Forks**: 7
- **Created**: 2026-08-31
- **Last Updated**: 2026-10-16

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

第四天：短期记忆
    1.为什么需要记忆
        - 大模型本身无状态，每次请求都是独立的
        - 在多轮对话中需要保存历史上下文，实现上下文感知
        - 解决：外部存储+自动注入历史记录
         用户输入-》读取历史-》构建messages-》模型处理-》解析输出-》写入messages
    2.核心组件
        - AgentState:agent内部管理当次会话的状态，默认有一个messages字段，记录当前聊天内容， invoke
        - Checkpointer:持久化状态（内存|数据库），支持跨invoke

    3.基本用法
        from langgraph.checkpointer.memory import InMemorySaver
        memory = InMemorySaver()
        create_agent(
            ...
            checkpointer=memory
        )

        config={"configurable":{"thread_id":"001"}}
        agent.invoke({"messages":[...]}, config)
        agent.invoke({"messages":[...]}, config)#自动将多次invoke中的messages拼接在一起

    4.状态：AgentState
        from langchain.agents import AgentState
        class MyAgentState(AgentState):
            user_id:str
            user_name:str
        agent = create_agent(
            state_schema=MyAgentState,
            checkpointer=memory
        )
        agent.invoke({"messages":[...],"user_id":"", "user_name":""}, config)

    5.消息管理
        中间件：
        5.1 裁剪 
        5.2 删除
        5.3 摘要
            
第五天：长期记忆
    1. 长短区别
        短期记忆：单会话
        长期记忆：跨会话，需要通过一个存储来实现
            语义提取：
             - 个人偏好：饮食、娱乐、消费偏好
             - 重要消息：姓名、关系、重要日期
             - 计划意图：即将发生的事件、目标
             - 服务偏好：餐饮、旅行、爱好相关
             - 健康信息：饮食限制、健身习惯
             - 专业信息：职业、工作习惯、目标
             - 杂项：喜欢的书籍、电影、品牌
    2. 长期记忆的API
        - Store实现存储

            namespace= ("应用", "场景")
            key = "确定该场景下的唯一标识符"
            store.put(namespace, key, value)
            store.get(namespace, key)
            
            store = InMemoryStore(index={"embed"：嵌入函数， "dims":维度})
            store.search(namespace, filter={}, query="") #相似检索 embedding
        - Store结合Agent
            
            #在agent中需要通过使用工具来实现具体的长期记忆的存储
            @tool
            def get(xxx, runtime):
                value = runtime.store.get(xxx)

            @tool
            def save(xxx, runtime):
                value="记忆"
                runtime.store.put(namepsace, key, value)

            agent = create_agent(
                ...
                tools=[get, save],
                store=store
            )


    3. 长短的结合
        agent =  create_agent(
            checkpointer=短期记忆,
            store=长期记忆
        )

        3.1 在agent的invoke过程中，会自动存储短期记忆
        3.2 在agent执行过程中，需要通过调用工具来实现长期记忆的存储

    4. mem0：分层记忆存储
        对话层：一次聊天
        会话层：短期
        用户层：长期，个人偏好、行为画像
        全局层：长期共享数据，团队知识、业务准则

第六天：中间件：内置中间件和自定义中间件
    1.中间件简介
        业务逻辑和推理逻辑分开，解耦，通过拓展新节点来实现该过程

        中间件的类型：6种+动态提示
         - 节点式： before_agent|after_agent、before_model|after_model
         - 包装式： wrap_tool_call、wrap_model_call

        执行流程：start -> before_agent -> before_model ->wrap_model_call -> model->wrap_tool_call-> tool -> after_model -> after_agent->end
    
    2. 内置中间件
        SummarizationMiddleware：摘要
        HumanInTheLoopMiddleware：人机交互
        ModelCallLimitMiddleware：模型调用次数限制
        ToolCallLimitMiddleware：工具调用次数限制
        ...
    
    3. 自定义中间件
        @before_agent:Agent启动前
        @after_agent:Agent结束前
        @before_model:模型调用前
        @after_model:模型调用后
              接受的参数：state:AgentState, runtime:Runtime

        @wrap_tool_call:工具调用前
        def wrap_tool(request:ToolCallRequest, handler:Callable[[ToolCallRequest], ToolMessage])
            
        @wrap_model_call:模型调用前
        def wrap_tool(request:ModelRequest, handler:Callable[[ModelRequest], ModelResponse])

第七天：
    1.流处理:Streaming，主要就是Agent（Model）在运行过程中实时获取信息,主要支持四种类型：
        - updates：Agent执行的每一步都会进行状态更新
        - messages：实时获取模型生成的每一个 token
        - customz:工具内部打印数据，get_stream_writer()获取流输出
        - 组合：通过监听多个状态["custom","messages"]
    
    2.MCP:模型上下文协议，规范Agent调用各种工具
        2.1 MCP架构
            host:负责与大模型进行交互的"工具"
            client:能够让大模型理解服务端具体的工具
            server：提供具体工具
            用户问题-》host-》agent-》client-》server-》agent-》用户回答
        2.3 传输机制
            - http|streamable-http:client和server分开， server只要暴露Http地址
            - stdio：client和server在同一个进程，通过标准输入输出流进行交互