LLM, RAG, LangChain, LangGraph, MCP 개념 및 예시

I. LLM (대규모 언어 모델)

개념

대규모 언어 모델(LLM)은 방대한 텍스트로 학습된 AI 시스템으로, 자연어를 이해하고 생성합니다. 핵심 원리는 다음 토큰 예측이며, 이를 통해 번역·요약·코드 생성 같은 다양한 작업을 수행합니다.

LLM의 한계

LLM에는 내재적 한계가 있으며, 이 때문에 RAG·MCP·LangChain 같은 기술이 등장했습니다.

• 환각(Hallucination): 사실이 아닌 내용을 그럴듯하게 생성
• 지식 단절(Knowledge Cutoff): 마지막 훈련 날짜 이후 정보 없음
• 도메인 특수성 부족: 전문 분야 깊이 있는 지식 부족
• 높은 컴퓨팅 비용: 대규모 자원 필요
• 편향(Bias): 훈련 데이터의 편향을 학습·증폭

산업별 응용

• 고객 서비스: 자동화 챗봇 및 대화형 에이전트
• 의료: 환자 보고서 분석 및 관리 업무 간소화
• 금융: 사기 탐지, 금융 리스크 평가
• 콘텐츠 제작: 기사, 마케팅 문구 등 텍스트 생성

기본 LLM 호출 예시

# pip install langchain-openai
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
response = llm.invoke("셀프 어텐션 개념을 한 문장으로 설명해줘.")
print(response.content)

II. RAG (검색 증강 생성)

개념

검색 증강 생성(RAG)은 응답 생성 전에 외부 지식 베이스에서 관련 정보를 검색하여 LLM 출력을 향상시키는 아키텍처 패턴입니다. LLM의 환각과 지식 단절 문제를 해결합니다.

RAG 파이프라인 구조

1단계: 데이터 인덱싱 (오프라인)

1. 데이터 로딩: PDF, 데이터베이스, API 등에서 데이터 수집
2. 청킹: 큰 문서를 작은 단위로 분할
3. 임베딩: 텍스트를 수치 벡터로 변환
4. 인덱싱: 벡터 DB에 저장 (Pinecone, Chroma, FAISS 등)

2단계: 검색 및 생성 (실시간)

1. 사용자 쿼리 입력
2. 쿼리 임베딩: 쿼리를 벡터로 변환
3. 검색: 유사한 문서 청크 검색
4. 증강: 검색 결과를 프롬프트에 추가
5. 생성: LLM이 맥락을 바탕으로 답변 생성

장단점

장점

• 정확성 향상 및 환각 감소
• 실시간 최신 데이터 접근
• 미세 조정보다 비용 효율적
• 출처 인용 가능 (투명성)
• 독점 데이터 프라이버시 보호

과제

• 검색 품질에 크게 의존
• 청킹 전략이 성능에 큰 영향
• 대규모 데이터 인덱싱 비용

RAG 파이프라인 vs. RAG 플랫폼

기능 RAG 파이프라인 (직접 구축) RAG 플랫폼 (통합 제품)

통합 노력	높음 — 구성 요소 직접 통합	낮음 — 즉시 사용 가능
프로덕션 준비성	낮음 — 직접 구축 필요	높음 — 엔터프라이즈급
확장성	복잡 — 수동 관리 필요	간편 — 자동 확장
유연성	매우 높음	제한적
가치 실현 시간	길다 (수개월)	짧다 (즉시)

주요 RAG 라이브러리

라이브러리 특징 최적 사용 사례

LangChain	방대한 통합, LCEL 체인	다양한 LLM 앱 프로토타이핑
LlamaIndex	데이터-LLM 연결 특화	대규모 데이터셋 RAG
Haystack	검색·QA 파이프라인	프로덕션급 검색 시스템

RAG 구현 예시

# pip install langchain langchain-openai faiss-cpu beautifulsoup4
from langchain_community.document_loaders import WebBaseLoader
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains import create_retrieval_chain
from langchain_openai import ChatOpenAI

loader = WebBaseLoader("<https://en.wikipedia.org/wiki/Large_language_model>")
docs = loader.load()

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splits = text_splitter.split_documents(docs)

embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(documents=splits, embedding=embeddings)
retriever = vectorstore.as_retriever()

llm = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_template("""다음 컨텍스트만 사용해서 답해줘:


{context}


질문: {input}""")

document_chain = create_stuff_documents_chain(llm, prompt)
retrieval_chain = create_retrieval_chain(retriever, document_chain)

response = retrieval_chain.invoke({"input": "What is a large language model?"})
print(response["answer"])

III. LangChain

개념

LangChain은 LLM 기반 애플리케이션 개발을 위한 오픈소스 프레임워크로, 다양한 구성 요소를 연결하는 '접착제' 역할을 합니다.

핵심 구성 요소

1. 모델(Models): LLM·채팅 모델·임베딩 모델을 위한 표준 인터페이스
2. 프롬프트(Prompts): 동적 프롬프트 템플릿 관리
3. 체인(Chains): LLM과 다른 구성 요소를 순차 결합 (LCEL 사용)
4. 검색(Retrieval): 문서 로더·분할기·벡터 저장소·검색기 (RAG 핵심)
5. 에이전트(Agents): LLM을 추론 엔진으로 사용, 도구 선택·실행
6. 메모리(Memory): 호출 간 상태 유지, 다중 턴 대화

장단점

강점

• 수백 개 서드파티 통합 제공
• 고수준 추상화로 빠른 프로토타이핑
• 공통 구성 요소 표준 인터페이스

약점

• 추상화가 디버깅을 어렵게 할 수 있음
• 빠른 변화로 호환성 문제 가능
• 복잡한 순환 워크플로우 구현 어려움 → LangGraph 사용

주요 사용 사례

• RAG 챗봇: 내부 문서 기반 Q&A
• 메모리 챗봇: 과거 대화를 기억하는 에이전트
• 문서 요약: 맵-리듀스 방식으로 긴 문서 요약
• 자동화 에이전트: 웹 검색 등 도구를 활용하는 에이전트

맵-리듀스 요약 예시

# pip install langchain langchain-openai
from langchain_openai import ChatOpenAI
from langchain.chains.summarize import load_summarize_chain
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.documents import Document

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

long_text = """
Large language models are advanced AI systems that understand and generate natural language.
LLMs are trained on vast amounts of text data.
However, LLMs have limitations such as knowledge cutoff and hallucination.
RAG connects LLMs to external knowledge bases to address these issues.
"""

docs = [Document(page_content=long_text)]
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
split_docs = text_splitter.split_documents(docs)

chain = load_summarize_chain(llm, chain_type="map_reduce")
summary = chain.invoke(split_docs)
print(summary['output_text'])

IV. LangGraph

개념

LangGraph는 LangChain의 확장으로, 상태를 가진 다중 에이전트 애플리케이션을 그래프 형태로 구성합니다. 루프·분기·조건 로직이 필요한 복잡한 워크플로우에 적합합니다.

핵심 구성 요소

• 상태(State): 그래프 전체에서 공유되는 데이터 구조 (TypedDict)
• 노드(Nodes): 작업 단위인 파이썬 함수 (LLM 호출, 도구 실행 등)
• 엣지(Edges): 노드 간 흐름 제어. 조건부 엣지로 동적 라우팅 가능

LangChain vs. LangGraph

기준 LangChain LangGraph

워크플로우	선형, 순차적 (DAG)	순환 그래프, 루프, 복잡한 분기
상태 관리	암시적 (메모리 객체)	명시적 중앙 집중 상태 객체
Human-in-the-Loop	구현 복잡	중단점 기능으로 기본 지원
다중 에이전트	제한적	기본 설계 목적
단순 작업	간단하고 직관적	설정 많이 필요, 과도할 수 있음

언제 사용할까?

LangChain 사용: 단순 순차 워크플로우, 기본 RAG 파이프라인

LangGraph 사용: 루프·자기 교정이 필요한 경우, 명시적 상태 관리, 다중 에이전트 협업, Human-in-the-Loop

LangGraph 상태 기반 에이전트 예시

# pip install langgraph langchain-openai pydantic
from typing import TypedDict, List, Optional
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langgraph.graph import StateGraph, END

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

class AgentState(TypedDict):
    task: str
    plan: Optional[List[str]]
    executed_steps: Optional[List[str]]
    response: str

class Plan(BaseModel):
    steps: List[str] = Field(description="실행할 단계 목록")

planner_prompt = ChatPromptTemplate.from_template("다음 작업을 위한 단계별 계획을 세워줘: {task}")
planner = (planner_prompt | llm).with_structured_output(Plan)

def plan_step(state: AgentState) -> dict:
    result = planner.invoke({"task": state['task']})
    return {"plan": result.steps, "executed_steps": []}

executor_prompt = ChatPromptTemplate.from_template(
    "'{step}' 단계를 실행해줘. 이전 단계: {executed_steps}. 작업: {task}"
)
executor = executor_prompt | llm

def execute_step(state: AgentState) -> dict:
    plan = state['plan']
    executed = state['executed_steps']
    current_step = plan[len(executed)]
    result = executor.invoke({
        "step": current_step,
        "executed_steps": ", ".join(executed) if executed else "없음",
        "task": state['task']
    })
    executed.append(f"{current_step}: {result.content}")
    return {"executed_steps": executed}

def final_response(state: AgentState) -> dict:
    return {"response": "\\n".join(state['executed_steps'])}

def should_continue(state: AgentState) -> str:
    return "continue" if len(state['executed_steps']) < len(state['plan']) else "end"

workflow = StateGraph(AgentState)
workflow.add_node("planner", plan_step)
workflow.add_node("executor", execute_step)
workflow.add_node("final_responder", final_response)

workflow.set_entry_point("planner")
workflow.add_edge("planner", "executor")
workflow.add_conditional_edges("executor", should_continue, {
    "continue": "executor",
    "end": "final_responder"
})
workflow.add_edge("final_responder", END)

app = workflow.compile()
result = app.invoke({"task": "RAG의 장점에 대한 블로그 포스트 작성"})
print(result['response'])

V. MCP (모델 컨텍스트 프로토콜)

개념

MCP(Model Context Protocol)는 AI 시스템이 외부 도구 및 데이터 소스와 통신하는 방식을 표준화한 오픈 표준입니다. "AI를 위한 USB-C" — 어떤 AI 모델도 MCP를 구현한 도구에 연결할 수 있습니다.

Anthropic이 만들었으며 OpenAI, Google DeepMind, Microsoft 등 주요 AI 기업이 채택했습니다.

구조

• MCP 서버: 도구와 데이터를 노출하는 애플리케이션
• MCP 클라이언트: AI 호스트에 내장되어 서버에 연결

주요 사용 사례

• 엔터프라이즈 어시스턴트: 챗봇을 내부 문서·CRM·지식 베이스에 연결
• 다중 도구 에이전트: 여러 도구 조율 (Google Drive 조회 후 Slack 전송 등)
• 개발 도구: AI를 IDE 및 개발 환경에 통합

fastMCP 사용 예시

# pip install fastmcp
import asyncio
from fastmcp import Client

async def main():
    client = Client("mcp://calendar.example.com")

    async with client:
        tools = await client.list_tools()
        print(f"사용 가능한 도구: {[tool.name for tool in tools]}")

        response = await client.call_tool(
            "create_event",
            {"title": "팀 미팅", "date": "2025-12-01"}
        )
        print(f"서버 응답: {response}")

asyncio.run(main())

<aside> ⚠️

보안 주의: MCP는 도구 및 데이터 접근을 허용하므로 프롬프트 주입, 과도한 권한 부여, 악의적 도구 등 보안 위험에 주의해야 합니다.

</aside>

VI. 기술 스택 통합

전체 아키텍처

각 기술은 경쟁 관계가 아닌 상호 보완적인 계층입니다.

1. LLM: 생성 능력의 기초
2. RAG: 외부 지식 베이스 연결, 환각 감소
3. LangChain: RAG 파이프라인 구성 및 오케스트레이션
4. LangGraph: 루프·조건·다중 에이전트 워크플로우 관리
5. MCP: 외부 도구·API와 표준화된 통신

도구 선택 가이드

• RAG: 정확성이 필요한 모든 앱의 출발점
• LangChain: 단순 순차 체인, 빠른 프로토타이핑
• LangGraph: 루프·조건·다중 에이전트 필요 시
• MCP: 외부 서비스 연결 표준화

미래 방향

패러다임은 단일 모델에서 모듈식·전문화·오케스트레이션된 시스템으로 이동 중입니다.

• "플로우 엔지니어링": 프롬프트 최적화보다 에이전트 행동 설계에 집중
• MCP 표준화로 도구 생태계 통합 가속
• Multi-Agent 시스템이 복잡한 실무 문제 해결의 핵심

VII. CrewAI

개념

CrewAI는 역할 기반 AI 에이전트들이 팀을 이루어 협업하는 Python 프레임워크입니다. 각 에이전트가 직무(role)·목표(goal)·배경(backstory)·도구(tools)를 가지고 일하며, Crew가 Process에 따라 Task를 처리합니다. 2026년 기준 안정 버전은 v1.14.3이며, Crew(자율 협업)와 Flow(이벤트 기반 결정론 워크플로우) 두 축으로 구성됩니다.

LangChain / LangGraph와의 차이

항목 LangChain LangGraph CrewAI

핵심 추상	LLM/도구/체인 빌딩 블록	상태 머신 그래프	역할 기반 에이전트 팀
코드량	중간	많음 (명시적 제어)	적음 (~20줄로 동작)
강점	도구 생태계, RAG	결정론, 체크포인트, HITL	빠른 프로토타이핑, 직관적 역할 분담
약점	멀티에이전트 추상 약함	보일러플레이트 많음	분기/루프 복잡한 워크플로에 부적합
LangChain 도구 호환	—	완전 호환	완전 호환 (LiteLLM 기반)

핵심 구성 요소

• Agent: role + goal + backstory + tools + llm + allow_delegation
• Task: description + expected_output + agent + context (이전 태스크 출력 주입)
• Crew: 에이전트·태스크 컨테이너. memory=True, cache=True, verbose=True 설정 가능
• Process: sequential (순서대로) / hierarchical (매니저 에이전트가 동적 위임)

뉴스 리서처 + 작가 예시

# pip install "crewai>=1.14" "crewai-tools"
from dotenv import load_dotenv
from crewai import Agent, Task, Crew, Process, LLM
from crewai_tools import SerperDevTool

load_dotenv()  # OPENAI_API_KEY, SERPER_API_KEY

llm = LLM(model="openai/gpt-4o-mini", temperature=0.2)
search_tool = SerperDevTool(n_results=5, search_type="news")

researcher = Agent(
    role="시니어 AI 뉴스 리서처",
    goal="{topic}에 대한 최근 7일 내 뉴스 5건을 찾아 요약한다.",
    backstory="10년 경력의 IT 저널리스트. 출처 URL과 발행일을 항상 포함한다.",
    tools=[search_tool],
    llm=llm,
    verbose=True,
)

writer = Agent(
    role="테크 콘텐츠 작가",
    goal="리서치 결과를 한국어 뉴스레터로 작성한다.",
    backstory="비전공 독자도 이해할 수 있는 기술 트렌드 작가.",
    llm=llm,
)

research_task = Task(
    description="{topic} 관련 최신 뉴스 5건 수집. 제목/날짜/출처/요점 3개/URL 포함.",
    expected_output="5개 항목의 마크다운 리스트",
    agent=researcher,
)

writing_task = Task(
    description="리서치 결과로 한국어 뉴스레터를 작성한다. 각 기사는 H3 + 4~5문장 + 원문 링크.",
    expected_output="발행 가능한 한국어 마크다운 뉴스레터",
    agent=writer,
    context=[research_task],
    output_file="newsletter.md",
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    memory=True,
    verbose=True,
)

result = crew.kickoff(inputs={"topic": "온디바이스 LLM 최신 동향"})
print(result.raw)

MCP 통합 예시

# pip install "crewai-tools[mcp]"
from mcp import StdioServerParameters
from crewai_tools import MCPServerAdapter
from crewai import Agent, Task, Crew

params = StdioServerParameters(command="uvx", args=["pubmedmcp@0.1.3"])
with MCPServerAdapter(params) as tools:
    agent = Agent(role="Medical Researcher", goal="PubMed 검색", tools=tools)
    task = Task(description="CRISPR 최신 논문 5건 요약", agent=agent,
                expected_output="요약 리스트")
    Crew(agents=[agent], tasks=[task]).kickoff()

언제 사용할까?

• CrewAI: 명확한 역할 분담, 빠른 프로토타이핑, 콘텐츠/리서치 파이프라인
• LangGraph: 분기·루프·Human-in-the-Loop·체크포인트가 필요한 경우
• 조합: LangGraph(외곽 컨트롤러) + CrewAI(내부 창의 협업 노드) + MCP(도구 표준)

VIII. Claude Code 개념

Claude Code vs Claude Desktop

항목 Claude Code (CLI) Claude Desktop (GUI)

설치	npm install -g @anthropic-ai/claude-code	claude.ai/download 에서 .dmg/.exe
주 사용 사례	코드베이스 작업, git 자동화, 멀티파일 리팩터링	일반 대화, 문서 작업, Artifacts 생성
에이전트/서브에이전트	Task 도구로 서브에이전트 스폰, 병렬 실행	없음
스킬 (Skill)	~/.claude/skills/ 슬래시 커맨드	Custom Skills (Claude.ai)
Hooks	settings.json 라이프사이클 이벤트	없음
Artifacts	없음 (파일 직접 편집)	우측 패널 인터랙티브 콘텐츠
MCP 추가 방법	claude mcp add <name>	.mcpb 더블클릭 또는 config.json
커넥터	제한적	Notion, GDrive, GitHub, Slack 등 50+

에이전트 & 서브에이전트

메인 에이전트는 사용자와 직접 대화하는 세션입니다. 서브에이전트는 Task 도구로 스폰되는 격리된 워커로, 독립적인 컨텍스트·권한·모델을 보유합니다.

# 단일 메시지에서 독립 태스크를 병렬로 실행 (최대 7개 동시)
Task({ subagent_type: "general-purpose", model: "haiku",  prompt: "파일 검색" })
Task({ subagent_type: "code-reviewer",  model: "sonnet", prompt: "코드 리뷰" })
Task({ subagent_type: "executor",       model: "opus",   prompt: "복잡한 구현" })

모델 라우팅: haiku (빠른 조회) / sonnet (표준, 기본) / opus (복잡한 분석)

서브에이전트 정의 파일: .claude/agents/<name>.md (프로젝트) 또는 ~/.claude/agents/<name>.md (글로벌)

스킬 (Skill)

/skill-name 슬래시 커맨드로 호출하거나 description 매칭으로 자동 트리거됩니다.

파일 위치: ~/.claude/skills/<name>/SKILL.md (글로벌) / .claude/skills/<name>/SKILL.md (프로젝트)

---
name: my-skill
description: When user asks for X, do Y...
---

# Skill 내용
구체적인 instructions...

초기에는 name + description만 로드하고 (≈100 토큰), 매칭되면 full body를 로드합니다 (≤5K 토큰).

툴 (Tool)

내장 툴: Read, Write, Edit, Bash, Task, Grep, Glob, WebFetch, WebSearch

Deferred 툴: 모든 툴 스키마를 한 번에 로드하지 않고 ToolSearch로 필요할 때 로드 → 컨텍스트 절약

# MCP 외부 툴 추가
claude mcp add github --scope user
claude mcp add playwright npx @playwright/mcp@latest

Hooks

주요 이벤트: PreToolUse / PostToolUse / UserPromptSubmit / Stop / SessionStart

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Write|Edit|MultiEdit",
      "hooks": [{
        "type": "command",
        "command": "npx prettier --write \\"$CLAUDE_TOOL_INPUT_FILE_PATH\\""
      }]
    }],
    "Stop": [{
      "hooks": [{ "type": "command", "command": "scripts/notify-done.sh" }]
    }]
  }
}

Exit code: 0 (통과) / 2 (PreToolUse에서 툴 차단, 또는 Stop hook에서 계속 강제)

메모리 (Memory)

**CLAUDE.md 계층** (우선순위 높은 순):

1. Managed Policy (관리자 배포)
2. Project Memory (./CLAUDE.md)
3. Project Rules (.claude/rules/*.md 자동 로드)
4. User Memory (~/.claude/CLAUDE.md)
5. Local Project (./CLAUDE.local.md)
6. Auto Memory

좋은 CLAUDE.md 예시:

# 프로젝트명

## 기술 스택
- Python 3.12, FastAPI, Postgres 16

## 빌드/테스트
- 빌드: `make build`
- 테스트: `pytest tests/`

## 컨벤션
- snake_case 함수, PascalCase 클래스
- public API는 type hint 필수

## 금지사항
- main 브랜치 직접 push 금지
- print() 디버깅 금지

@.claude/rules/api-design.md

자동 메모리 시스템: ~/.claude/projects/<encoded-cwd>/memory/MEMORY.md (인덱스)

• 타입: user / feedback / project / reference
• <remember>: 7일 단기 / <remember priority>: 영구 저장

아티팩트 (Artifact)

Claude.ai Web / Desktop 전용 기능. 우측 패널에 렌더링되는 독립 콘텐츠입니다.

생성 조건: 15줄 이상의 자립적 콘텐츠, 편집/재사용 가능성 높은 콘텐츠

유형: 코드, HTML/CSS/JS 웹페이지 (실제 렌더링), React 컴포넌트 (실행), Mermaid 다이어그램, SVG

Claude Code에서는 아티팩트 개념이 없으며 파일을 직접 편집합니다.

디스패치 (Dispatch)

서브에이전트로 작업을 위임하는 패턴입니다.

• 병렬: 단일 메시지에서 여러 Task 호출 → 독립 태스크에 적합
• 순차: 앞 Task 결과가 다음 Task 입력일 때 — 메시지를 분리해서 호출

루틴 (Routine)

2026년 4월 출시. Anthropic 클라우드 인프라에서 실행되는 스케줄 작업으로, 노트북을 닫아도 실행됩니다.

# 스케줄링 방식
1. Cloud Routines: /routine 커맨드
2. Desktop Scheduled Tasks: 로컬 머신
3. /loop 커맨드: 세션 내 반복

내장 도구: CronCreate (5필드 cron 표현식) / CronDelete / CronList

사용 사례: 매일 PR 리뷰, 주간 의존성 업데이트, 새벽 빌드 모니터링

settings.json 전체 구조

{
  "permissions": {
    "allow": ["Bash(npm run *)", "Bash(git commit *)", "Read(**)"],
    "ask":   ["Bash(git push *)"],
    "deny":  ["Bash(rm -rf *)", "Write(/etc/**)"] 
  },
  "env": {
    "DEBUG": "true"
  },
  "hooks": {
    "PreToolUse": [{
      "matcher": "Bash",
      "hooks": [{ "type": "command", "command": "scripts/audit.sh" }]
    }]
  },
  "model": "claude-opus-4-7"
}

위치 (우선순위 순): .claude/settings.local.json > .claude/settings.json > ~/.claude/settings.json

Claude API 빠른 참조

# pip install anthropic
from anthropic import Anthropic

client = Anthropic()  # ANTHROPIC_API_KEY 자동 인식

# 기본 호출
message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    system="You are a helpful coding assistant.",
    messages=[{"role": "user", "content": "Explain async/await."}],
)
print(message.content[0].text)

# 스트리밍
with client.messages.stream(
    model="claude-opus-4-7", max_tokens=1024,
    messages=[{"role": "user", "content": "Write a haiku"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# Prompt Caching (최대 90% 비용 절감)
response = client.messages.create(
    model="claude-opus-4-7", max_tokens=1024,
    system=[{
        "type": "text",
        "text": "<긴 정적 지시사항...>",
        "cache_control": {"type": "ephemeral"}  # 5분 캐시
    }],
    messages=[{"role": "user", "content": "질문"}]
)

oh-my-claudecode (OMC)

Claude Code용 멀티에이전트 오케스트레이션 레이어입니다.

스킬 용도

/oh-my-claudecode:autopilot	계획 → 구현 → 검증 → 리뷰 자동 파이프라인
/oh-my-claudecode:ralph	Architect 승인까지 계획/수정/검증 반복
/oh-my-claudecode:ultrawork	다중 에이전트 동시 발사, 모델 티어 라우팅
/oh-my-claudecode:team	명시적 팀 오케스트레이션
/oh-my-claudecode:cancel	실행 모드 종료

IX. Playwright / tmux / 부수 도구

Playwright

Playwright는 Microsoft가 만든 오픈소스 E2E(End-to-End) 테스트 프레임워크입니다. Chromium·Firefox·WebKit 브라우저를 코드로 제어하며, AI 에이전트가 웹 브라우저를 자동화할 때도 폭넓게 활용됩니다.

주요 특징

• 크로스 브라우저: Chromium / Firefox / WebKit 단일 API
• 자동 대기(Auto-wait): 요소가 안정될 때까지 자동 대기 → 불안정한 sleep 불필요
• 네트워크 가로채기: 요청 모킹, 응답 스텁
• 스크린샷·PDF: 전체 페이지/특정 요소 캡처
• MCP 서버: npx @playwright/mcp@latest — Claude Code에서 브라우저 조작 가능

기본 사용 예시

# pip install playwright && playwright install
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()

    page.goto("<https://example.com>")
    page.fill("#search", "LLM")
    page.click("button[type=submit]")
    page.wait_for_selector(".results")

    title = page.title()
    screenshot = page.screenshot(path="result.png")
    print(f"페이지 제목: {title}")

    browser.close()

Claude Code에서 Playwright MCP 사용

# MCP 서버 추가
claude mcp add playwright npx @playwright/mcp@latest

# 이후 Claude가 브라우저를 직접 제어 가능
# mcp__playwright__browser_navigate, browser_click, browser_snapshot 등

pytest-playwright E2E 테스트 예시

# pip install pytest-playwright
# pytest --browser chromium
import pytest
from playwright.sync_api import Page, expect

def test_login(page: Page):
    page.goto("<https://myapp.com/login>")
    page.fill("[name=email]", "user@example.com")
    page.fill("[name=password]", "secret")
    page.click("button[type=submit]")
    expect(page).to_have_url("<https://myapp.com/dashboard>")
    expect(page.locator("h1")).to_contain_text("대시보드")

tmux

tmux는 터미널 다중화(multiplexer) 도구입니다. 하나의 터미널 세션에서 여러 창(window)과 패널(pane)을 관리하고, SSH 연결이 끊겨도 세션이 유지됩니다. AI 에이전트 실습에서 백그라운드 프로세스를 관찰하거나 병렬 작업을 모니터링할 때 핵심 도구입니다.

구조

• Session: tmux 최상위 단위. 여러 Window 포함
• Window: 브라우저의 탭처럼 독립된 터미널 화면
• Pane: 하나의 Window 안에서 분할된 터미널

주요 명령어

목적 명령어

세션 생성	tmux new -s mySession
세션 목록	tmux ls
세션 재연결	tmux attach -t mySession
세션 분리	Ctrl+B → D
세션 종료	tmux kill-session -t mySession
창 새로 만들기	Ctrl+B → C
창 전환	Ctrl+B → 숫자키 (0, 1, 2…)
수직 분할 pane	Ctrl+B → %
수평 분할 pane	Ctrl+B → "
pane 간 이동	Ctrl+B → 화살표키
pane 닫기	exit 또는 Ctrl+D
화면 캡처	tmux capture-pane -pt mySession

AI 에이전트 실습에서의 활용

# 백엔드 서버 / 프론트엔드 / 에이전트 로그를 pane 3개로 분할 모니터링
tmux new -s dev
tmux split-window -h          # 우측 pane 추가
tmux split-window -v          # 우측에서 수평 추가

# Pane 0: 백엔드
tmux send-keys -t dev:0.0 'uvicorn main:app --reload' Enter

# Pane 1: 프론트엔드
tmux send-keys -t dev:0.1 'npm run dev' Enter

# Pane 2: 에이전트 로그
tmux send-keys -t dev:0.2 'tail -f agent.log' Enter

벡터 DB 비교

RAG 파이프라인에서 임베딩 벡터를 저장하고 검색하는 데이터베이스입니다.

DB 특징 호스팅 최적 사용 사례

ChromaDB	로컬/인메모리, 설정 최소화, Python 친화	로컬 / 자체 호스팅	프로토타이핑, 소규모 RAG
FAISS	Meta 오픈소스, 초고속 CPU/GPU 검색	로컬 (인메모리)	오프라인 대규모 배치 검색
Pinecone	완전 관리형, 실시간 업데이트, 메타데이터 필터	클라우드 SaaS	프로덕션 RAG, 엔터프라이즈
Weaviate	그래프 + 벡터 하이브리드, 멀티모달	클라우드 / 자체 호스팅	복잡한 지식 그래프 + 검색
pgvector	PostgreSQL 확장, SQL + 벡터 통합	자체 Postgres 서버	기존 Postgres 스택에 벡터 추가

AI 에이전트 패턴

에이전트가 문제를 해결하는 대표적인 실행 패턴입니다.

패턴 동작 방식 구현 도구

ReAct	Reasoning(추론) + Acting(행동) 반복: 생각 → 도구 실행 → 관찰	LangChain Agent, LangGraph
Reflection	출력 생성 후 자기 비평 → 개선 루프	LangGraph (순환 그래프)
Plan-and-Execute	먼저 전체 계획 수립, 이후 단계별 실행	LangGraph, CrewAI hierarchical
Multi-Agent	역할별 전문 에이전트가 협업·위임	CrewAI, LangGraph Multi-Agent

LLM 관찰성 (Observability) 도구

LLM 애플리케이션의 호출 추적, 평가, 디버깅을 위한 도구입니다.

도구 특징 LangChain 통합

LangSmith	LangChain 공식, 트레이스·평가·데이터셋 관리	환경변수만 설정하면 자동 수집
W&B Weave	Weights & Biases, 실험 추적 + LLM 로깅 통합	weave.init() 후 자동 패치
Arize Phoenix	오픈소스, 로컬 실행, RAG 평가 특화	OpenInference 계측

LangSmith 빠른 설정

export LANGCHAIN_TRACING_V2=true
export LANGCHAIN_API_KEY=<your-key>
export LANGCHAIN_PROJECT=my-rag-project

# 이후 LangChain 코드 그대로 실행 → LangSmith에 자동 트레이스 수집

기타 유용한 라이브러리

라이브러리 역할 주요 특징

LlamaIndex	데이터-LLM 연결 RAG 프레임워크	대규모 데이터 인덱싱, 쿼리 엔진
Pydantic AI	구조화된 LLM 출력 + 에이전트	타입 안전 결과, 유효성 검사
Instructor	LLM 응답을 Pydantic 모델로 파싱	response_model 파라미터 하나로 구조화
Semantic Kernel	Microsoft의 LLM 오케스트레이션 SDK	C# / Python / Java, Azure AI 통합