모델 컨텍스트 프로토콜(MCP): AI 통합 가이드

curl -LsSf https://astral.sh/uv/install.sh | sh 

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Create a new directory for the MCP server project
uv init server
cd server

# Create virtual environment and activate it
uv venv
source .venv/bin/activate

# Install dependencies
uv add "mcp[cli]" httpx weave openai

# Create the server file
touch server.py

# Create a new directory for the MCP server project
uv init server
cd server

# Create virtual environment and activate it
uv venv
.venv\Scripts\Activate

# Install dependencies
uv add "mcp[cli]" httpx weave openai

# Create the server file
New-Item -ItemType File server.py


sh -x setup.sh 

from typing import Any
import os
from mcp.server.fastmcp import FastMCP
from openai import OpenAI
import weave; weave.init("mcp_tools")


# Initialize FastMCP server
mcp = FastMCP("mcp_server")

# Initialize OpenAI client for web search
search_client = OpenAI(api_key="your_openai_key")

# Initialize DeepSeek R1 client
r1_api_key = "your_deepseek_key"
r1_client = OpenAI(api_key=r1_api_key, base_url="https://api.deepseek.com")


# External function for web search
@weave.op
async def run_web_search(query: str) -> str:
    try:
        response = search_client.responses.create(
            model="gpt-4o",
            tools=[{"type": "web_search_preview"}],
            input=query
        )
        return response.output_text
    except Exception as e:
        return f"Search failed: {str(e)}"


# MCP Tool: Web Search
@mcp.tool()
async def web_search(query: str) -> str:
    try:
        return await run_web_search(query)
    except Exception as e:
        return f"Search failed: {str(e)}"


# External function for R1 reasoning
@weave.op
async def run_r1_reasoning(prompt: str) -> str:
    try:
        if not r1_api_key:
            return "Error: DeepSeek API key not set."
            
        response = r1_client.chat.completions.create(
            model="deepseek-reasoner",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    except Exception as e:
        return f"DeepSeek-R1 reasoning failed: {str(e)}"


# MCP Tool: R1 Reasoning
@mcp.tool()
async def r1_reasoning(prompt: str) -> str:
    return await run_r1_reasoning(prompt)


# External function for retrieving memory preferences
@weave.op
def get_writing_preferences() -> str:
    preferences = {
        "writing_preferences": {
            "headers": "unstyled - no bold headers in articles",
            "terminology": "use 'LLM' - everyone knows what it means",
            "avoid_words": ["crucial", "paramount", "critical", "essential", "invaluable", "In the provided script"],
            "formatting": "no bullets or lists in articles",
            "commands": {
                "--c": "only write necessary changes, not full code",
                "--q": "answer concisely and quickly",
                "--a": "write full code from beginning to end",
                "--nb": "rewrite without bullets or lists"
            },
            "absolute_dont": ["use canvas for writing code", "say 'structured workflow'"]
        }
    }
    return str(preferences)


# MCP Resource: Writing Preferences
@mcp.resource("file://memory")
def get_memory() -> str:
    return get_writing_preferences()


# External function for summarization prompt
@weave.op
def generate_summarization_prompt(text: str) -> str:
    FIXED_QUESTIONS = """
    What is the primary objective of this research?
    What methodologies or algorithms are proposed or evaluated?
    What datasets or experimental setups are used in this study?
    What are the key findings and contributions of this research?
    What are the implications of these findings for the broader field of AI?
    What limitations or challenges are acknowledged by the authors?
    What are the proposed future directions or next steps in this research?
    """
    return f"Summarize the following text by answering these questions:\n{FIXED_QUESTIONS}\n\n{text}"


# MCP Prompt: Summarization
@mcp.prompt()
def summarization_prompt(text: str) -> str:
    return generate_summarization_prompt(text)


# Run the MCP Server
if __name__ == "__main__":
    mcp.run(transport='stdio')

code ~/Library/Application\ Support/Claude/claude_desktop_config.json

code $env:APPDATA\Claude\claude_desktop_config.json