에이전트에서의 컨텍스트 엔지니어링

from langchain.agents import create_agent
from langchain.agents.middleware import dynamic_prompt, ModelRequest

@dynamic_prompt
def state_aware_prompt(request: ModelRequest) -> str:
    # request.messages는 request.state["messages"]의 단축키입니다
    message_count = len(request.messages)

    base = "You are a helpful assistant."

    if message_count > 10:
        base += "\nThis is a long conversation - be extra concise."

    return base

agent = create_agent(
    model="openai:gpt-4o",
    tools=[...],
    middleware=[state_aware_prompt]
)

from langchain.agents import create_agent
from langchain.agents.middleware import wrap_model_call, ModelRequest, ModelResponse
from typing import Callable

@wrap_model_call
def inject_file_context(
    request: ModelRequest,
    handler: Callable[[ModelRequest], ModelResponse]
) -> ModelResponse:
    """사용자가 이 세션에서 업로드한 파일에 대한 컨텍스트를 주입합니다."""
    # 상태에서 읽기: 업로드된 파일 메타데이터 가져오기
    uploaded_files = request.state.get("uploaded_files", [])  

    if uploaded_files:
        # 사용 가능한 파일에 대한 컨텍스트 구축
        file_descriptions = []
        for file in uploaded_files:
            file_descriptions.append(
                f"- {file['name']} ({file['type']}): {file['summary']}"
            )

        file_context = f"""Files you have access to in this conversation:
{chr(10).join(file_descriptions)}

Reference these files when answering questions."""

        # 최근 메시지 이전에 파일 컨텍스트 주입
        messages = [  
            *request.messages
            {"role": "user", "content": file_context},
        ]
        request = request.override(messages=messages)  

    return handler(request)

agent = create_agent(
    model="openai:gpt-4o",
    tools=[...],
    middleware=[inject_file_context]
)

from langchain.agents import create_agent
from langchain.agents.middleware import wrap_model_call, ModelRequest, ModelResponse
from typing import Callable

@wrap_model_call
def state_based_tools(
    request: ModelRequest,
    handler: Callable[[ModelRequest], ModelResponse]
) -> ModelResponse:
    """대화 상태에 따라 도구를 필터링합니다."""
    # 상태에서 읽기: 사용자가 인증되었는지 확인
    state = request.state  
    is_authenticated = state.get("authenticated", False)  
    message_count = len(state["messages"])

    # 인증 후에만 민감한 도구 활성화
    if not is_authenticated:
        tools = [t for t in request.tools if t.name.startswith("public_")]
        request = request.override(tools=tools)  
    elif message_count < 5:
        # 대화 초기에는 도구 제한
        tools = [t for t in request.tools if t.name != "advanced_search"]
        request = request.override(tools=tools)  

    return handler(request)

agent = create_agent(
    model="openai:gpt-4o",
    tools=[public_search, private_search, advanced_search],
    middleware=[state_based_tools]
)

from langchain.agents import create_agent
from langchain.agents.middleware import wrap_model_call, ModelRequest, ModelResponse
from langchain.chat_models import init_chat_model
from typing import Callable

# 미들웨어 외부에서 모델을 한 번 초기화
large_model = init_chat_model("anthropic:claude-sonnet-4-5")
standard_model = init_chat_model("openai:gpt-4o")
efficient_model = init_chat_model("openai:gpt-4o-mini")

@wrap_model_call
def state_based_model(
    request: ModelRequest,
    handler: Callable[[ModelRequest], ModelResponse]
) -> ModelResponse:
    """상태 대화 길이에 따라 모델을 선택합니다."""
    # request.messages는 request.state["messages"]의 단축키입니다
    message_count = len(request.messages)  

    if message_count > 20:
        # 긴 대화 - 더 큰 컨텍스트 윈도우를 가진 모델 사용
        model = large_model
    elif message_count > 10:
        # 중간 대화
        model = standard_model
    else:
        # 짧은 대화 - 효율적인 모델 사용
        model = efficient_model

    request = request.override(model=model)  

    return handler(request)

agent = create_agent(
    model="openai:gpt-4o-mini",
    tools=[...],
    middleware=[state_based_model]
)

from langchain.agents import create_agent
from langchain.agents.middleware import wrap_model_call, ModelRequest, ModelResponse
from pydantic import BaseModel, Field
from typing import Callable

class SimpleResponse(BaseModel):
    """초기 대화를 위한 간단한 응답입니다."""
    answer: str = Field(description="간략한 답변")

class DetailedResponse(BaseModel):
    """확립된 대화를 위한 상세한 응답입니다."""
    answer: str = Field(description="상세한 답변")
    reasoning: str = Field(description="추론 설명")
    confidence: float = Field(description="신뢰도 점수 0-1")

@wrap_model_call
def state_based_output(
    request: ModelRequest,
    handler: Callable[[ModelRequest], ModelResponse]
) -> ModelResponse:
    """상태에 따라 출력 형식을 선택합니다."""
    # request.messages는 request.state["messages"]의 단축키입니다
    message_count = len(request.messages)  

    if message_count < 3:
        # 초기 대화 - 간단한 형식 사용
        request = request.override(response_format=SimpleResponse)  
    else:
        # 확립된 대화 - 상세한 형식 사용
        request = request.override(response_format=DetailedResponse)  

    return handler(request)

agent = create_agent(
    model="openai:gpt-4o",
    tools=[...],
    middleware=[state_based_output]
)

from langchain.tools import tool, ToolRuntime
from langchain.agents import create_agent

@tool
def check_authentication(
    runtime: ToolRuntime
) -> str:
    """사용자가 인증되었는지 확인합니다."""
    # 상태에서 읽기: 현재 인증 상태 확인
    current_state = runtime.state
    is_authenticated = current_state.get("authenticated", False)

    if is_authenticated:
        return "User is authenticated"
    else:
        return "User is not authenticated"

agent = create_agent(
    model="openai:gpt-4o",
    tools=[check_authentication]
)

from langchain.tools import tool, ToolRuntime
from langchain.agents import create_agent
from langgraph.types import Command

@tool
def authenticate_user(
    password: str,
    runtime: ToolRuntime
) -> Command:
    """사용자를 인증하고 상태를 업데이트합니다."""
    # 인증 수행 (단순화됨)
    if password == "correct":
        # 상태에 쓰기: Command를 사용하여 인증됨으로 표시
        return Command(
            update={"authenticated": True},
        )
    else:
        return Command(update={"authenticated": False})

agent = create_agent(
    model="openai:gpt-4o",
    tools=[authenticate_user]
)