로컬 LLM 에이전트 구축 가이드 — Ollama·LangGraph·MCP(Model Context Protocol)로 코드 리뷰 에이전트와 RAG 파이프라인 구현하기

# 1. Ollama 설치 후 모델 다운로드
brew install ollama           # macOS
# Linux: curl -fsSL https://ollama.com/install.sh | sh
 
ollama pull codellama:7b      # 약 3.8GB, 코드 특화 모델
 
# 2. 의존성 설치 (버전 명시)
pip install "langgraph>=0.2" "langchain-ollama>=0.1" "langchain-core>=0.3"

# code_review_agent.py
from langchain_ollama import ChatOllama
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator
import subprocess
 
# 상태 정의
# TypedDict: 노드 간에 전달되는 데이터의 구조와 타입을 선언합니다.
# LangGraph는 이 구조를 기반으로 상태를 직렬화하고 노드 사이에서 안전하게 전달합니다.
# Annotated[list[str], operator.add]: 여러 노드가 issues에 값을 추가할 때
# 기존 리스트를 덮어쓰지 않고 자동으로 합치는 리듀서(reducer)를 지정합니다.
class ReviewState(TypedDict):
    file_path: str
    code: str
    lint_result: str
    review_result: str
    issues: Annotated[list[str], operator.add]
    iteration: int
 
# 로컬 LLM 초기화 (API 키 불필요)
llm = ChatOllama(
    model="codellama:7b",
    base_url="http://localhost:11434",  # Ollama 기본 엔드포인트
    temperature=0.1,                    # 낮을수록 일관된 출력
)
 
# 린트 노드 — ruff로 정적 분석 후 결과를 상태에 저장
def lint_node(state: ReviewState) -> ReviewState:
    result = subprocess.run(
        ["ruff", "check", state["file_path"]],
        capture_output=True, text=True
    )
    return {**state, "lint_result": result.stdout or "린트 오류 없음"}
 
# 리뷰 노드 — 코드와 린트 결과를 LLM에 전달하여 리뷰 생성
def review_node(state: ReviewState) -> ReviewState:
    prompt = f"""다음 코드를 리뷰하고 개선이 필요한 점을 JSON 형식으로 반환하세요.
 
코드:
{state['code']}
 
린트 결과:
{state['lint_result']}
 
응답 형식: {{"issues": ["문제1", "문제2"]}}"""
 
    response = llm.invoke(prompt)
    return {
        **state,
        "review_result": response.content,
        "iteration": state["iteration"] + 1,
    }
 
# 그래프 구성: lint → review → END
graph = StateGraph(ReviewState)
graph.add_node("lint", lint_node)
graph.add_node("review", review_node)
graph.set_entry_point("lint")
graph.add_edge("lint", "review")
graph.add_edge("review", END)
 
agent = graph.compile()
 
# 실행 — with 블록으로 파일 핸들이 반드시 닫히도록 보장
with open("my_module.py", "r") as f:
    code = f.read()
 
result = agent.invoke({
    "file_path": "my_module.py",
    "code": code,
    "lint_result": "",
    "review_result": "",
    "issues": [],
    "iteration": 0,
})
print(result["review_result"])

# 실행
python code_review_agent.py

# Ollama 모델 다운로드
ollama pull mistral:7b           # 약 4.1GB, 범용 텍스트 처리
ollama pull nomic-embed-text     # 274MB, 로컬 임베딩 전용
 
# 의존성 설치 — langchain-ollama는 OllamaEmbeddings 포함
pip install "langchain-ollama>=0.1" "langchain-chroma>=0.1" chromadb \
            "langchain-community>=0.3" "langchain-core>=0.3"

# local_rag_pipeline.py
# LangChain 0.3 이상 기준으로 작성
from operator import itemgetter
from langchain_ollama import ChatOllama, OllamaEmbeddings
from langchain_chroma import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import DirectoryLoader
from langchain_core.prompts import ChatPromptTemplate
 
# 1. 로컬 임베딩 모델 (외부 API 호출 없음)
embeddings = OllamaEmbeddings(model="nomic-embed-text")
 
# 2. 문서 로드 및 청크 분할
loader = DirectoryLoader("./company_docs", glob="**/*.md")
docs = loader.load()
 
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
)
chunks = splitter.split_documents(docs)
 
# 3. 로컬 벡터 DB에 저장
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db",  # 로컬 디스크에 저장
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
 
# 4. RAG 체인 구성 (LangChain 0.3+ 권장 LCEL 문법)
# itemgetter로 딕셔너리 키를 안전하게 추출
llm = ChatOllama(model="mistral:7b", temperature=0)
 
prompt = ChatPromptTemplate.from_template("""
다음 컨텍스트만을 사용하여 질문에 답하세요.
컨텍스트에 없는 내용은 "문서에서 찾을 수 없습니다"라고 답하세요.
 
컨텍스트:
{context}
 
질문: {question}
""")
 
rag_chain = (
    {
        "context": itemgetter("question") | retriever,
        "question": itemgetter("question"),
    }
    | prompt
    | llm
)
 
# 5. 질의 — rag_chain 끝에 ChatOllama가 있으므로 반환값은 AIMessage 객체
response = rag_chain.invoke({"question": "온보딩 절차가 어떻게 되나요?"})
print(response.content)

# 실행
python local_rag_pipeline.py

# MCP 어댑터 및 서버 의존성 설치
pip install "langchain-mcp-adapters>=0.1" "langchain-ollama>=0.1" \
            fastapi uvicorn

# tool_server/main.py
from fastapi import FastAPI
from pydantic import BaseModel
 
app = FastAPI()
 
class BrowseRequest(BaseModel):
    url: str
 
@app.post("/tools/extract_text")
async def extract_text(req: BrowseRequest) -> dict:
    """지정된 URL의 텍스트를 추출합니다."""
    # 실제 구현에서는 httpx 또는 playwright 사용
    return {"result": f"{req.url}에서 추출한 텍스트 (예시)"}
 
# MCP 도구 목록 엔드포인트 — 프로토콜 요구사항
@app.get("/mcp/tools")
async def list_tools():
    return {
        "tools": [
            {
                "name": "extract_text",
                "description": "URL에서 텍스트를 추출합니다",
                "inputSchema": {
                    "type": "object",
                    "properties": {"url": {"type": "string"}},
                    "required": ["url"],
                },
            }
        ]
    }

# mcp_agent.py
import asyncio
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_ollama import ChatOllama
 
llm = ChatOllama(model="mistral:7b", temperature=0.1)
 
async def main():
    # MCP 클라이언트가 도구 서버에서 사용 가능한 도구 목록을 자동으로 탐색
    async with MultiServerMCPClient(
        {
            "browser-tools": {
                "url": "http://localhost:8000/mcp",
                "transport": "streamable_http",
            }
        }
    ) as mcp_client:
        # 탐색된 도구를 LangChain 호환 형태로 변환 후 에이전트에 등록
        tools = mcp_client.get_tools()
        agent = create_react_agent(llm, tools)
 
        response = await agent.ainvoke(
            {"messages": [{"role": "user", "content": "https://example.com 페이지의 텍스트를 추출해줘"}]}
        )
        print(response["messages"][-1].content)
 
asyncio.run(main())

# 터미널 1: 도구 서버 실행
uvicorn tool_server.main:app --port 8000
 
# 터미널 2: 에이전트 실행
python mcp_agent.py