Day 31 — 통합 프로젝트: Runpod → vLLM → Local LLM → LangGraph → MCP → RAG → FastAPI → Web UI

┌─────────────────────────────────────────────────────────────────────┐
│  사용자 (브라우저)                                                     │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │  Web UI (Next.js / Streamlit / Gradio 등)                      │  │
│  │  - 채팅 인터페이스, 스트리밍 응답 렌더링                            │  │
│  └───────────────────────────────────────────────────────────────┘  │
└───────────────────────────────┬───────────────────────────────────┘
                                 │ HTTPS (SSE/WebSocket 스트리밍)
┌───────────────────────────────▼───────────────────────────────────┐
│  FastAPI 백엔드 (자체 서버 또는 Runpod 위 별도 컨테이너)                  │
│  - POST /chat  → LangGraph 에이전트 invoke                          │
│  - Langfuse CallbackHandler로 전 구간 트레이싱                        │
└───────────────────────────────┬───────────────────────────────────┘
                                 │
┌───────────────────────────────▼───────────────────────────────────┐
│  LangGraph 에이전트 (StateGraph)                                     │
│                                                                     │
│   [입력] → router 노드 → ┬─ RAG 필요? → retrieve 노드 ─┐             │
│                          ├─ 도구 필요? → tool_call 노드 ┤            │
│                          └─ 바로 답변? ──────────────┐ │             │
│                                                       ▼ ▼             │
│                                              generate 노드 (LLM 호출) │
└──────┬───────────────────────────┬───────────────────────┬────────┘
       │                           │                       │
       ▼                           ▼                       ▼
┌─────────────┐        ┌────────────────────┐   ┌────────────────────┐
│ MCP 클라이언트 │        │  RAG 파이프라인       │   │  vLLM 추론 서버       │
│ → MCP 서버   │        │  - 임베딩 모델        │   │  (Runpod GPU Pod)   │
│  (도구 실행)  │        │  - 벡터DB (검색)      │   │  - Local LLM        │
│              │        │  - 문서 청크 저장소    │   │  - OpenAI 호환 API   │
└─────────────┘        └────────────────────┘   └────────────────────┘

# graph.py — LangGraph 에이전트 정의
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from typing import TypedDict, Annotated
import operator

# vLLM이 OpenAI 호환 API로 떠 있으므로 base_url만 바꿔서 연결
llm = ChatOpenAI(
    base_url="http://runpod-vllm-endpoint:8000/v1",
    api_key="dummy",  # vLLM 자체 인증 미사용 시
    model="local-llama-3.1-8b",
)

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    route: str

def router_node(state: AgentState):
    last_msg = state["messages"][-1].content
    # 간단한 라우팅 로직 (실무에서는 LLM 분류 또는 임베딩 유사도 활용)
    if "주문" in last_msg or "환불" in last_msg:
        return {"route": "tool"}
    if "정책" in last_msg or "문서" in last_msg:
        return {"route": "rag"}
    return {"route": "direct"}

def rag_node(state: AgentState):
    from rag import retrieve_context
    query = state["messages"][-1].content
    context = retrieve_context(query, top_k=3)
    prompt = f"다음 문서를 참고해 답하세요:\n{context}\n\n질문: {query}"
    response = llm.invoke(prompt)
    return {"messages": [response]}

def tool_node(state: AgentState):
    from mcp_client import call_mcp_tool
    query = state["messages"][-1].content
    tool_result = call_mcp_tool("get_order_status", {"query": query})
    response = llm.invoke(f"도구 실행 결과: {tool_result}\n\n이를 바탕으로 사용자에게 답하세요.")
    return {"messages": [response]}

def direct_node(state: AgentState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

graph = StateGraph(AgentState)
graph.add_node("router", router_node)
graph.add_node("rag", rag_node)
graph.add_node("tool", tool_node)
graph.add_node("direct", direct_node)
graph.set_entry_point("router")
graph.add_conditional_edges(
    "router",
    lambda state: state["route"],
    {"rag": "rag", "tool": "tool", "direct": "direct"},
)
graph.add_edge("rag", END)
graph.add_edge("tool", END)
graph.add_edge("direct", END)

agent = graph.compile()

# rag.py — 최소 RAG 검색 함수
from qdrant_client import QdrantClient
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vector_db = QdrantClient(url="http://localhost:6333")

def retrieve_context(query: str, top_k: int = 3) -> str:
    query_vector = embeddings.embed_query(query)
    hits = vector_db.search(
        collection_name="company_docs",
        query_vector=query_vector,
        limit=top_k,
    )
    return "\n---\n".join(hit.payload["text"] for hit in hits)

# mcp_client.py — MCP 도구 호출 래퍼 (개념 스켈레톤)
from mcp import ClientSession

async def call_mcp_tool(tool_name: str, arguments: dict) -> str:
    async with ClientSession(server_url="http://localhost:9000/mcp") as session:
        result = await session.call_tool(tool_name, arguments)
        return result.content[0].text

# main.py — FastAPI 진입점
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from langfuse.callback import CallbackHandler
from graph import agent

app = FastAPI()
langfuse_handler = CallbackHandler()

class ChatRequest(BaseModel):
    message: str
    session_id: str

@app.post("/chat")
async def chat(req: ChatRequest):
    config = {
        "callbacks": [langfuse_handler],
        "metadata": {"langfuse_session_id": req.session_id},
    }
    result = agent.invoke(
        {"messages": [("user", req.message)]},
        config=config,
    )
    return {"answer": result["messages"][-1].content}