LangChain v1.0 中间件详解：彻底搞定 AI Agent 上下文控制

 from langchain.agents import AgentExecutor, create_openai_tools_agent  
from langchain_openai import ChatOpenAI  

tools = [search_tool, calculator_tool, database_tool]  
llm = ChatOpenAI(model="gpt-4")  
agent = create_openai_tools_agent(llm, tools, prompt)  
# Too many confusing settings!  
agent_executor = AgentExecutor(  
    agent=agent,  
    tools=tools,  
    max_iterations=15,              # How many times can it try?  
    max_execution_time=300,         # How long can it run?  
    handle_parsing_errors=True,     # What if something breaks?  
    return_intermediate_steps=True, # Show me the steps?  
    trim_intermediate_steps=10,     # How much to remember?  
    # and many more confusing options...  
 )

 def custom_agent_loop(user_input, tools, llm):  
    messages = [{"role": "user", "content": user_input}]  
      
    for iteration in range(10):  
        # You have to manually do everything!  
        if len(messages) > 20:  
            messages = summarize_history(messages)  # Clean up old messages  
          
        available_tools = select_tools(messages, tools)  # Pick which tools to use  
        system_prompt = generate_prompt(iteration)  # Create instructions  
          
        response = llm.invoke(messages, tools=available_tools)  
         # And more manual work...

 from langchain.agents import create_agent  
from langchain.agents.middleware import (  
    PIIMiddleware,  
    SummarizationMiddleware,  
    HumanInTheLoopMiddleware  
)  
agent = create_agent(  
    model="claude-sonnet-4-5-20250929",  
    tools=[read_email, send_email],  
    middleware=[  
        # Hide email addresses automatically (privacy protection)  
        PIIMiddleware("email", strategy="redact"),  
          
        # Block phone numbers completely (extra privacy)  
        PIIMiddleware("phone_number", strategy="block"),  
          
        # When conversation gets long, make a short summary  
        # (like creating a highlight reel of a long movie)  
        SummarizationMiddleware(  
            model="claude-sonnet-4-5-20250929",  
            max_tokens_before_summary=500  
        ),  
          
        # Before sending emails, ask a human "Is this okay?"  
        # (like a safety check before hitting send)  
        HumanInTheLoopMiddleware(  
            interrupt_on={  
                "send_email": {  
                    "allowed_decisions": ["approve", "edit", "reject"]  
                }  
            }  
        ),  
    ]  
 )

 from dataclasses import dataclass  
from typing import Callable  
from langchain_openai import ChatOpenAI  
from langchain.agents.middleware import AgentMiddleware, ModelRequest  
from langchain.agents.middleware.types import ModelResponse  

# First, define what you want to track about users  
@dataclass  
class Context:  
    user_expertise: str = "beginner"  # Is user a beginner or expert?  



# Create your custom middleware  
class ExpertiseBasedToolMiddleware(AgentMiddleware):  
    def wrap_model_call(  
        self,  
        request: ModelRequest,  
        handler: Callable[[ModelRequest], ModelResponse]  
    ) -> ModelResponse:  

        # Check: Is this user a beginner or expert?  
        user_level = request.runtime.context.user_expertise  
          
        if user_level == "expert":  
            # Experts get powerful AI and advanced tools  
            model = ChatOpenAI(model="gpt-5")  
            tools = [advanced_search, data_analysis]  
        else:  
            # Beginners get simpler AI and basic tools  
            model = ChatOpenAI(model="gpt-5-nano")  
            tools = [simple_search, basic_calculator]  
          
        # Update what the AI sees  
        request.model = model  
        request.tools = tools  
          
        # Send it forward to the AI  
        return handler(request)  


     
# Now use your custom middleware (just like the built-in ones!)  
agent = create_agent(  
    model="claude-sonnet-4-5-20250929",  
    tools=[simple_search, advanced_search, basic_calculator, data_analysis],  
    middleware=[ExpertiseBasedToolMiddleware()],  # Your custom middleware here!  
    context_schema=Context  
 )