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

import { createAgent } from "langchain";

const agent = createAgent({
  model: "openai:gpt-4o",
  tools: [...],
  middleware: [
    dynamicSystemPromptMiddleware((state) => {
      // 상태에서 읽기: 대화 길이 확인
      const messageCount = state.messages.length;

      let base = "You are a helpful assistant.";

      if (messageCount > 10) {
        base += "\nThis is a long conversation - be extra concise.";
      }

      return base;
    }),
  ],
});

import { createMiddleware } from "langchain";

const injectFileContext = createMiddleware({
  name: "InjectFileContext",
  wrapModelCall: (request, handler) => {
    // request.state는 request.state.messages의 단축키입니다
    const uploadedFiles = request.state.uploadedFiles || [];  

    if (uploadedFiles.length > 0) {
      // 사용 가능한 파일에 대한 컨텍스트 구축
      const fileDescriptions = uploadedFiles.map(file =>
        `- ${file.name} (${file.type}): ${file.summary}`
      );

      const fileContext = `Files you have access to in this conversation:
${fileDescriptions.join("\n")}

Reference these files when answering questions.`;

      // 최근 메시지 이전에 파일 컨텍스트 주입
      const messages = [  
        ...request.messages  // 대화의 나머지 부분
        { role: "user", content: fileContext }
      ];
      request = request.override({ messages });  
    }

    return handler(request);
  },
});

const agent = createAgent({
  model: "openai:gpt-4o",
  tools: [...],
  middleware: [injectFileContext],
});

import { createMiddleware } from "langchain";

const stateBasedTools = createMiddleware({
  name: "StateBasedTools",
  wrapModelCall: (request, handler) => {
    // 상태에서 읽기: 인증 및 대화 길이 확인
    const state = request.state;  
    const isAuthenticated = state.authenticated || false;  
    const messageCount = state.messages.length;

    let filteredTools = request.tools;

    // 인증 후에만 민감한 도구 활성화
    if (!isAuthenticated) {
      filteredTools = request.tools.filter(t => t.name.startsWith("public_"));  
    } else if (messageCount < 5) {
      filteredTools = request.tools.filter(t => t.name !== "advanced_search");  
    }

    return handler({ ...request, tools: filteredTools });  
  },
});

import { createMiddleware, initChatModel } from "langchain";

// 미들웨어 외부에서 모델을 한 번 초기화
const largeModel = initChatModel("anthropic:claude-sonnet-4-5");
const standardModel = initChatModel("openai:gpt-4o");
const efficientModel = initChatModel("openai:gpt-4o-mini");

const stateBasedModel = createMiddleware({
  name: "StateBasedModel",
  wrapModelCall: (request, handler) => {
    // request.messages는 request.state.messages의 단축키입니다
    const messageCount = request.messages.length;  
    let model;

    if (messageCount > 20) {
      model = largeModel;
    } else if (messageCount > 10) {
      model = standardModel;
    } else {
      model = efficientModel;
    }

    return handler({ ...request, model });  
  },
});

import { createMiddleware } from "langchain";
import { z } from "zod";

const simpleResponse = z.object({
  answer: z.string().describe("간략한 답변"),
});

const detailedResponse = z.object({
  answer: z.string().describe("상세한 답변"),
  reasoning: z.string().describe("추론 설명"),
  confidence: z.number().describe("신뢰도 점수 0-1"),
});

const stateBasedOutput = createMiddleware({
  name: "StateBasedOutput",
  wrapModelCall: (request, handler) => {
    // request.state는 request.state.messages의 단축키입니다
    const messageCount = request.messages.length;  

    if (messageCount < 3) {
      // 초기 대화 - 간단한 형식 사용
      responseFormat = simpleResponse; 
    } else {
      // 확립된 대화 - 상세한 형식 사용
      responseFormat = detailedResponse; 
    }

    return handler({ ...request, responseFormat });
  },
});

import * as z from "zod";
import { tool } from "@langchain/core/tools";
import { createAgent } from "langchain";

const checkAuthentication = tool(
  async (_, { runtime }) => {
    // 상태에서 읽기: 현재 인증 상태 확인
    const currentState = runtime.state;
    const isAuthenticated = currentState.authenticated || false;

    if (isAuthenticated) {
      return "User is authenticated";
    } else {
      return "User is not authenticated";
    }
  },
  {
    name: "check_authentication",
    description: "사용자가 인증되었는지 확인",
    schema: z.object({}),
  }
);

import * as z from "zod";
import { tool } from "@langchain/core/tools";
import { createAgent } from "langchain";
import { Command } from "@langchain/langgraph";

const authenticateUser = tool(
  async ({ password }, { runtime }) => {
    // 인증 수행
    if (password === "correct") {
      // 상태에 쓰기: Command를 사용하여 인증됨으로 표시
      return new Command({
        update: { authenticated: true },
      });
    } else {
      return new Command({ update: { authenticated: false } });
    }
  },
  {
    name: "authenticate_user",
    description: "사용자를 인증하고 상태를 업데이트",
    schema: z.object({
      password: z.string(),
    }),
  }
);