LLM 게이트웨이 MCP 서버

고성능 AI 에이전트에서 비용 효율적인 LLM으로의 지능형 위임을 가능하게 하는 MCP(Model Context Protocol) 서버

LLM 게이트웨이란 무엇인가요?

LLM Gateway는 Claude 3.7 Sonnet과 같은 고급 AI 에이전트에서 Gemini Flash 2.0 Lite와 같은 비용 효율적인 모델로 지능적인 작업 위임을 지원하는 MCP 네이티브 서버입니다. 여러 LLM(대규모 언어 모델) 제공업체에 대한 통합 인터페이스를 제공하는 동시에 비용, 성능 및 품질을 최적화합니다.

비전: AI 기반 리소스 최적화

LLM Gateway는 근본적으로 AI 시스템과의 상호작용 방식에 근본적인 변화를 가져옵니다. 모든 작업에 단일 고비용 모델을 사용하는 대신, 다음과 같은 지능형 계층 구조를 구현합니다.

Claude 3.7과 같은 고급 모델은 고수준 추론, 오케스트레이션 및 복잡한 작업에 중점을 둡니다.
비용 효율적인 모델은 일상적인 처리, 추출 및 기계 작업을 처리합니다.
전체 시스템은 비용의 일부만으로 최고 수준의 성능을 달성합니다.

이러한 접근 방식은 인간 조직의 작동 방식을 반영합니다. 즉, 전문가가 복잡한 결정을 내리는 동시에 해당 작업에 적합한 기술을 갖춘 다른 사람에게 일상적인 업무를 위임합니다.

MCP 네이티브 아키텍처

이 서버는 모델 컨텍스트 프로토콜(MCP)을 기반으로 구축되어 Claude와 같은 AI 에이전트와 함께 작동하도록 특별히 설계되었습니다. 모든 기능은 이러한 에이전트가 직접 호출할 수 있는 MCP 도구를 통해 제공되므로 AI 간 위임을 위한 원활한 워크플로가 구축됩니다.

주요 사용 사례: AI 에이전트 작업 위임

LLM Gateway의 주요 설계 목표는 Claude 3.7 Sonnet과 같은 정교한 AI 에이전트가 비용이 덜 드는 모델에 작업을 지능적으로 위임할 수 있도록 하는 것입니다.

지엑스피1

워크플로 예시:

Claude는 문서를 요약해야 한다는 것을 식별합니다(Claude를 사용하는 경우 비용이 많이 드는 작업).
Claude는 MCP 도구를 통해 이 작업을 LLM Gateway에 위임합니다.
LLM Gateway는 요약 작업을 Gemini Flash로 라우팅합니다(Claude보다 10~20배 저렴).
요약은 더 높은 수준의 추론과 의사 결정을 위해 Claude에게 반환됩니다.
그러면 Claude는 자신의 지능이 실제로 필요한 작업에 역량을 집중할 수 있습니다.

이 위임 패턴을 사용하면 출력 품질을 유지하면서 API 비용을 70-90% 절감할 수 있습니다.

LLM Gateway를 사용해야 하는 이유는 무엇입니까?

🔄 AI-AI 작업 위임

가장 강력한 사용 사례는 고급 AI 에이전트가 일상적인 작업을 더 저렴한 모델에 위임할 수 있도록 하는 것입니다.

Claude 3.7에서 초기 문서 요약을 위해 GPT-4o-mini를 사용하도록 합니다.
Claude가 Gemini 2.0 플래시 라이트를 사용하여 데이터 추출 및 변환을 수행하도록 하세요.
Claude가 다양한 공급자에 걸쳐 다단계 워크플로를 조율할 수 있도록 허용
Claude가 각 특정 하위 작업에 적합한 모델을 선택할 수 있도록 합니다.

💰 비용 최적화

고급 모델의 API 비용은 상당할 수 있습니다. LLM Gateway는 다음과 같은 방법으로 비용을 절감하는 데 도움이 됩니다.

더 저렴한 모델에 적절한 작업 라우팅(예: 1K 토큰당 $0.01 대 1K 토큰당 $0.15)
중복된 API 호출을 방지하기 위해 고급 캐싱 구현
공급업체 간 비용 추적 및 최적화
비용 인식 작업 라우팅 결정 활성화

🔄 공급자 추상화

통합된 인터페이스를 통해 공급자 종속을 방지하세요.

OpenAI, Anthropic(Claude), Google(Gemini) 및 DeepSeek용 표준 API
일관된 매개변수 처리 및 응답 형식
애플리케이션 코드를 변경하지 않고도 공급자를 교체할 수 있는 기능
공급자별 중단 및 제한에 대한 보호

📄 대규모 문서 처리

대용량 문서를 효율적으로 처리하세요:

문서를 의미적으로 의미 있는 부분으로 나누세요
여러 모델에서 병렬로 청크 처리
비정형 텍스트에서 구조화된 데이터 추출
방대한 텍스트에서 요약과 통찰력을 생성합니다.

주요 특징

MCP 프로토콜 통합

네이티브 MCP 서버 : AI 에이전트 통합을 위한 모델 컨텍스트 프로토콜 기반
MCP 도구 프레임워크 : 표준화된 MCP 도구를 통해 노출되는 모든 기능
도구 구성 : 복잡한 워크플로를 위해 도구를 결합할 수 있습니다.
도구 검색 : 도구 목록 및 기능 검색 지원

지능형 작업 위임

작업 라우팅 : 작업을 분석하고 적절한 모델로 라우팅합니다.
공급자 선택 : 작업 요구 사항에 따라 공급자를 선택하세요
비용-성능 균형 : 비용, 품질 또는 속도 최적화
위임 추적 : 위임 패턴 및 결과 모니터링

고급 캐싱

다중 레벨 캐싱 : 다중 캐싱 전략:
- 정확한 일치 캐싱
- 의미적 유사성 캐싱
- 작업 인식 캐싱
영구 캐시 : 빠른 메모리 내 액세스를 갖춘 디스크 기반 지속성
캐시 분석 : 저장량 및 적중률 추적

문서 도구

스마트 청킹 : 다중 청킹 전략:
- 토큰 기반 청킹
- 의미적 경계 감지
- 구조 분석
문서 작업 :
- 요약
- 엔티티 추출
- 질문 생성
- 일괄 처리

구조화된 데이터 추출

JSON 추출 : 스키마 검증을 통해 구조화된 JSON 추출
테이블 추출 : 다양한 포맷의 테이블 추출
키-값 추출 : 텍스트에서 키-값 쌍 추출
의미 스키마 추론 : 텍스트에서 스키마 생성

토너먼트 모드

코드 및 텍스트 경연 대회 : 토너먼트 스타일 경연 대회 운영 지원
다중 모델 : 여러 모델의 출력을 동시에 비교
성능 지표 : 모델 성능 평가 및 추적
결과 저장 : 추가 분석을 위해 토너먼트 결과를 보관합니다.

고급 벡터 연산

의미 검색 : 문서 전체에서 의미적으로 유사한 콘텐츠 찾기
벡터 저장 : 벡터 임베딩의 효율적인 저장 및 검색
하이브리드 검색 : 키워드와 의미 검색 기능을 결합합니다.
일괄 처리 : 대용량 데이터 세트를 효율적으로 처리합니다.

사용 예

Claude가 문서 분석을 위해 LLM Gateway를 사용함

이 예에서는 Claude가 LLM Gateway를 사용하여 작업을 저렴한 모델에 위임하여 문서를 처리하는 방법을 보여줍니다.

import asyncio
from mcp.client import Client

async def main():
    # Claude would use this client to connect to the LLM Gateway
    client = Client("http://localhost:8013")
    
    # Claude can identify a document that needs processing
    document = "... large document content ..."
    
    # Step 1: Claude delegates document chunking
    chunks_response = await client.tools.chunk_document(
        document=document,
        chunk_size=1000,
        method="semantic"
    )
    print(f"Document divided into {chunks_response['chunk_count']} chunks")
    
    # Step 2: Claude delegates summarization to a cheaper model
    summaries = []
    total_cost = 0
    for i, chunk in enumerate(chunks_response["chunks"]):
        # Use Gemini Flash (much cheaper than Claude)
        summary = await client.tools.summarize_document(
            document=chunk,
            provider="gemini",
            model="gemini-2.0-flash-lite",
            format="paragraph"
        )
        summaries.append(summary["summary"])
        total_cost += summary["cost"]
        print(f"Processed chunk {i+1} with cost ${summary['cost']:.6f}")
    
    # Step 3: Claude delegates entity extraction to another cheap model
    entities = await client.tools.extract_entities(
        document=document,
        entity_types=["person", "organization", "location", "date"],
        provider="openai",
        model="gpt-4o-mini"
    )
    total_cost += entities["cost"]
    
    print(f"Total delegation cost: ${total_cost:.6f}")
    # Claude would now process these summaries and entities using its advanced capabilities
    
    # Close the client when done
    await client.close()

if __name__ == "__main__":
    asyncio.run(main())

의사 결정을 위한 다중 공급자 비교

# Claude can compare outputs from different providers for critical tasks
responses = await client.tools.multi_completion(
    prompt="Explain the implications of quantum computing for cryptography.",
    providers=[
        {"provider": "openai", "model": "gpt-4o-mini", "temperature": 0.3},
        {"provider": "anthropic", "model": "claude-3-haiku-20240307", "temperature": 0.3},
        {"provider": "gemini", "model": "gemini-2.0-pro", "temperature": 0.3}
    ]
)

# Claude could analyze these responses and decide which is most accurate
for provider_key, result in responses["results"].items():
    if result["success"]:
        print(f"{provider_key} Cost: ${result['cost']}")

비용 최적화된 워크플로

# Claude can define and execute complex multi-stage workflows
workflow = [
    {
        "name": "Initial Analysis",
        "operation": "summarize",
        "provider": "gemini",
        "model": "gemini-2.0-flash-lite",
        "input_from": "original",
        "output_as": "summary"
    },
    {
        "name": "Entity Extraction",
        "operation": "extract_entities",
        "provider": "openai",
        "model": "gpt-4o-mini",
        "input_from": "original", 
        "output_as": "entities"
    },
    {
        "name": "Question Generation",
        "operation": "generate_qa",
        "provider": "deepseek",
        "model": "deepseek-chat",
        "input_from": "summary",
        "output_as": "questions"
    }
]

# Execute the workflow
results = await client.tools.execute_optimized_workflow(
    documents=[document],
    workflow=workflow
)

print(f"Workflow completed in {results['processing_time']:.2f}s")
print(f"Total cost: ${results['total_cost']:.6f}")

문서 청킹

큰 문서를 작고 관리하기 쉬운 덩어리로 나누려면:

large_document = "... your very large document content ..."

chunking_response = await client.tools.chunk_document(
    document=large_document,
    chunk_size=500,     # Target size in tokens
    overlap=50,         # Token overlap between chunks
    method="semantic"   # Or "token", "structural"
)

if chunking_response["success"]:
    print(f"Document divided into {chunking_response['chunk_count']} chunks.")
    # chunking_response['chunks'] contains the list of text chunks
else:
    print(f"Error: {chunking_response['error']}")

다중 공급자 완료

비교를 위해 여러 공급업체/모델에서 동일한 프롬프트에 대한 완성을 동시에 얻으려면:

multi_response = await client.tools.multi_completion(
    prompt="What are the main benefits of using the MCP protocol?",
    providers=[
        {"provider": "openai", "model": "gpt-4o-mini"},
        {"provider": "anthropic", "model": "claude-3-haiku-20240307"},
        {"provider": "gemini", "model": "gemini-2.0-flash-lite"}
    ],
    temperature=0.5
)

if multi_response["success"]:
    print("Multi-completion results:")
    for provider_key, result in multi_response["results"].items():
        if result["success"]:
            print(f"--- {provider_key} ---")
            print(f"Completion: {result['completion']}")
            print(f"Cost: ${result['cost']:.6f}")
        else:
            print(f"--- {provider_key} Error: {result['error']} ---")
else:
    print(f"Multi-completion failed: {multi_response['error']}")

구조화된 데이터 추출(JSON)

텍스트에서 특정 JSON 스키마로 정보를 추출하려면:

text_with_data = "User John Doe (john.doe@example.com) created an account on 2024-07-15. His user ID is 12345."

desired_schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "email": {"type": "string", "format": "email"},
        "creation_date": {"type": "string", "format": "date"},
        "user_id": {"type": "integer"}
    },
    "required": ["name", "email", "creation_date", "user_id"]
}

json_response = await client.tools.extract_json(
    document=text_with_data,
    json_schema=desired_schema,
    provider="openai", # Choose a provider capable of structured extraction
    model="gpt-4o-mini"
)

if json_response["success"]:
    print(f"Extracted JSON: {json_response['json_data']}")
    print(f"Cost: ${json_response['cost']:.6f}")
else:
    print(f"Error: {json_response['error']}")

검색 증강 생성(RAG) 쿼리

RAG를 사용하여 질문을 하려면 시스템이 답변을 생성하기 전에 관련 컨텍스트를 검색해야 합니다(관련 문서가 색인되었다고 가정).

rag_response = await client.tools.rag_query( # Assuming a tool name like rag_query
    query="What were the key findings in the latest financial report?",
    # Parameters to control retrieval, e.g.:
    # index_name="financial_reports",
    # top_k=3, 
    provider="anthropic",
    model="claude-3-haiku-20240307" # Model to generate the answer based on context
)

if rag_response["success"]:
    print(f"RAG Answer:\n{rag_response['answer']}")
    # Potentially include retrieved sources: rag_response['sources']
    print(f"Cost: ${rag_response['cost']:.6f}")
else:
    print(f"Error: {rag_response['error']}")

융합 검색(키워드 + 의미론)

Marqo를 사용하여 키워드 관련성과 의미적 유사성을 결합한 하이브리드 검색을 수행하려면:

fused_search_response = await client.tools.fused_search( # Assuming a tool name like fused_search
    query="impact of AI on software development productivity",
    # Parameters for Marqo index and tuning:
    # index_name="tech_articles",
    # keyword_weight=0.3, # Weight for keyword score (0.0 to 1.0)
    # semantic_weight=0.7, # Weight for semantic score (0.0 to 1.0)
    # top_n=5,
    # filter_string="year > 2023"
)

if fused_search_response["success"]:
    print(f"Fused Search Results ({len(fused_search_response['results'])} hits):")
    for hit in fused_search_response["results"]:
        print(f" - Score: {hit['_score']:.4f}, ID: {hit['_id']}, Content: {hit.get('text', '')[:100]}...")
else:
    print(f"Error: {fused_search_response['error']}")

로컬 텍스트 처리

LLM API를 호출하지 않고 로컬 오프라인 텍스트 작업을 수행하려면:

# Assuming a tool that bundles local text functions
local_process_response = await client.tools.process_local_text( 
    text="  Extra   spaces   and\nnewlines\t here.  ",
    operations=[
        {"action": "trim_whitespace"},
        {"action": "normalize_newlines"},
        {"action": "lowercase"}
    ]
)

if local_process_response["success"]:
    print(f"Processed Text: '{local_process_response['processed_text']}'")
else:
    print(f"Error: {local_process_response['error']}")

모델 토너먼트 운영

특정 작업(예: 코드 생성)에서 여러 모델의 출력을 비교하려면 다음을 수행합니다.

# Assuming a tournament tool
tournament_response = await client.tools.run_model_tournament(
    task_type="code_generation",
    prompt="Write a Python function to calculate the factorial of a number.",
    competitors=[
        {"provider": "openai", "model": "gpt-4o-mini"},
        {"provider": "anthropic", "model": "claude-3-opus-20240229"}, # Higher-end model for comparison
        {"provider": "deepseek", "model": "deepseek-coder"}
    ],
    evaluation_criteria=["correctness", "efficiency", "readability"],
    # Optional: ground_truth="def factorial(n): ..." 
)

if tournament_response["success"]:
    print("Tournament Results:")
    # tournament_response['results'] would contain rankings, scores, outputs
    for rank, result in enumerate(tournament_response.get("ranking", [])):
        print(f"  {rank+1}. {result['provider']}/{result['model']} - Score: {result['score']:.2f}")
    print(f"Total Cost: ${tournament_response['total_cost']:.6f}")
else:
    print(f"Error: {tournament_response['error']}")

(더 많은 도구 예시를 여기에 추가할 수 있습니다...)

시작하기

설치

# Install uv if you don't already have it:
curl -LsSf https://astral.sh/uv/install.sh | sh

# Clone the repository
git clone https://github.com/yourusername/llm_gateway_mcp_server.git
cd llm_gateway_mcp_server

# Install in venv using uv:
uv venv --python 3.13
source .venv/bin/activate
uv pip install -e ".[all]"

환경 설정

API 키로 .env 파일을 만듭니다.

# API Keys (at least one provider required)
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
GEMINI_API_KEY=your_gemini_key
DEEPSEEK_API_KEY=your_deepseek_key

# Server Configuration
SERVER_PORT=8013
SERVER_HOST=127.0.0.1

# Logging Configuration
LOG_LEVEL=INFO
USE_RICH_LOGGING=true

# Cache Configuration
CACHE_ENABLED=true
CACHE_TTL=86400

서버 실행

# Start the MCP server
python -m llm_gateway.cli.main run

# Or with Docker
docker compose up

서버를 실행하면 http://localhost:8013 에서 사용할 수 있습니다.

고급 구성

.env 파일은 기본적인 설정에 편리한 반면, LLM Gateway는 주로 환경 변수를 통해 관리되는 더 자세한 구성 옵션을 제공합니다.

서버 구성

SERVER_HOST : (기본값: 127.0.0.1 ) 서버가 수신 대기하는 네트워크 인터페이스입니다. 모든 인터페이스에서 수신 대기하려면 0.0.0.0 사용하세요(Docker 또는 외부 액세스에 필요).
SERVER_PORT : (기본값: 8013 ) 서버가 수신하는 포트입니다.
API_PREFIX : (기본값: / ) API 엔드포인트의 URL 접두사입니다.

로깅 구성

LOG_LEVEL : (기본값: INFO ) 로그의 자세한 정도를 제어합니다. 옵션: DEBUG , INFO , WARNING , ERROR , CRITICAL .
USE_RICH_LOGGING : (기본값: true ) Rich 라이브러리를 사용하여 다채로운 형식의 콘솔 로그를 생성합니다. 일반 텍스트 로그를 생성하려면 false 로 설정합니다(파일 리디렉션이나 일부 로그 집계 시스템에 더 적합).
LOG_FORMAT : (선택 사항) 사용자 정의 로그 형식 문자열을 지정합니다.
LOG_TO_FILE : (선택 사항, 예: gateway.log ) 로그를 작성해야 하는 파일의 경로입니다.

캐시 구성

CACHE_ENABLED : (기본값: true ) 캐싱을 전역적으로 활성화하거나 비활성화합니다.
CACHE_TTL : (기본값: 86400 초, 즉 24시간) 캐시된 항목의 기본 TTL(Time-To-Live)입니다. 특정 도구에서 이 값을 재정의할 수 있습니다.
CACHE_TYPE : (기본값: memory ) 캐시 백엔드 유형입니다. 옵션으로는 memory , redis , diskcache 이 있습니다. ( 참고: 지원되는 유형은 현재 구현을 확인하세요 .)
CACHE_MAX_SIZE : (선택 사항) 캐시의 최대 항목 수 또는 메모리 크기입니다.
REDIS_URL : ( CACHE_TYPE=redis 인 경우 필수) Redis 캐시 서버의 연결 URL(예: redis://localhost:6379/0 ).

공급자 시간 초과 및 재시도

PROVIDER_TIMEOUT : (기본값: 120 초) LLM 공급자 API에 대한 요청에 대한 기본 시간 초과입니다.
PROVIDER_MAX_RETRIES : (기본값: 3 ) 실패한 공급자 요청에 대한 기본 재시도 횟수(예: 일시적인 네트워크 문제 또는 속도 제한으로 인해).
특정 공급자의 시간 초과/재시도는 OPENAI_TIMEOUT , ANTHROPIC_MAX_RETRIES 등의 전용 변수를 통해 구성할 수 있습니다( 참고: 현재 구현을 확인하세요 ).

도구별 구성

일부 도구는 구성을 위한 자체 환경 변수(예: 통합 검색을 위한 MARQO_URL , 기본 청킹 매개변수)를 가질 수 있습니다. 각 도구의 설명서나 소스 코드를 참조하세요.

서버를 시작하기 전에 환경 변수가 올바르게 설정되었는지 항상 확인하세요. 변경 사항이 있으면 서버를 다시 시작해야 하는 경우가 많습니다.

배포 고려 사항

python 이나 docker compose up 사용하여 서버를 직접 실행하는 것은 개발 및 테스트에 적합하지만, 보다 견고하거나 프로덕션 배포에 적합한 경우 다음 사항을 고려하세요.

1. 백그라운드 서비스로 실행

게이트웨이가 지속적으로 실행되고 장애 발생 시 또는 서버 재부팅 시 자동으로 다시 시작되도록 하려면 프로세스 관리자를 사용하세요.

systemd (Linux): 프로세스를 관리하기 위한 서비스 단위 파일(예: /etc/systemd/system/llm-gateway.service )을 생성합니다. 이렇게 하면 sudo systemctl start|stop|restart|status llm-gateway 와 같은 명령을 실행할 수 있습니다.
supervisor : Python으로 작성된 인기 있는 프로세스 제어 시스템입니다. supervisord 구성하여 게이트웨이 프로세스를 모니터링하고 제어합니다.
Docker 재시작 정책: Docker(독립형 또는 Compose)를 사용하는 경우 docker run 명령이나 docker-compose.yml 파일에서 적절한 재시작 정책(예: unless-stopped 또는 always )을 구성합니다.

2. 역방향 프록시 사용(Nginx/Caddy/Apache)

LLM 게이트웨이 앞에 역방향 프록시를 배치하는 것이 좋습니다.

HTTPS/SSL 종료: 프록시는 SSL 인증서를 처리할 수 있습니다(예: Caddy와 함께 Let's Encrypt 사용 또는 Nginx/Apache와 함께 Certbot 사용). 이때 클라이언트와 프록시 간의 트래픽은 암호화됩니다.
부하 분산: 높은 가용성이나 성능을 위해 게이트웨이의 여러 인스턴스를 실행해야 하는 경우 프록시가 트래픽을 인스턴스 간에 분산할 수 있습니다.
경로 라우팅: 외부 경로(예: https://api.yourdomain.com/llm-gateway/ )를 내부 게이트웨이 서버( http://localhost:8013 )에 매핑합니다.
보안 헤더: 중요한 보안 헤더(CSP, HSTS 등)를 추가합니다.
버퍼링/캐싱: 일부 프록시는 추가적인 요청/응답 버퍼링이나 캐싱 기능을 제공합니다.

Nginx location 블록 예시(간소화):

location /llm-gateway/ {
    proxy_pass http://127.0.0.1:8013/;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    # Add configurations for timeouts, buffering, etc.
}

3. 컨테이너 오케스트레이션(Kubernetes/Swarm)

컨테이너화된 환경에 배포하는 경우:

상태 점검: 배포 매니페스트에서 상태 점검 엔드포인트(예: 앞서 언급한 /healthz )를 구현하고 구성하여 오케스트레이터가 서비스 상태를 모니터링할 수 있도록 합니다.
구성: 이미지에 하드코딩하거나 .env 파일에만 의존하는 대신, ConfigMaps 및 Secrets(Kubernetes) 또는 이와 동등한 메커니즘을 사용하여 환경 변수와 API 키를 안전하게 관리합니다.
리소스 제한: 안정적인 성능을 보장하고 리소스 부족을 방지하기 위해 게이트웨이 컨테이너에 대한 적절한 CPU 및 메모리 요청/제한을 정의합니다.
서비스 검색: IP 주소나 호스트 이름을 하드코딩하는 대신 오케스트레이터의 서비스 검색 메커니즘을 활용합니다.

4. 자원 할당

특히 메모리 내 캐싱을 사용하거나 대용량 문서/요청을 처리하는 경우 호스트 머신이나 컨테이너에 충분한 RAM이 있는지 확인하세요.
특히 부하가 심하거나 여러 복잡한 작업이 동시에 실행되는 경우 CPU 사용량을 모니터링합니다.

위임을 통한 비용 절감

위임을 위해 LLM Gateway를 사용하면 상당한 비용 절감 효과를 얻을 수 있습니다.

일	클로드 3.7 직접	더 저렴한 LLM으로 위임됨	저금
100페이지 분량의 문서 요약	4.50달러	0.45달러(제미니 플래시)	90%
50개 레코드에서 데이터 추출	2.25달러	0.35달러(GPT-4o-미니)	84%
20개의 콘텐츠 아이디어 생성	0.90달러	0.12달러(딥시크)	87%
1,000건의 고객 문의 처리	45.00달러	7.50달러(혼합 위임)	83%

클로드가 고수준 추론과 오케스트레이션에 집중하는 동안 기계적 작업은 비용 효율적인 모델에 위임함으로써 고품질의 결과물을 유지하면서 이러한 비용 절감이 달성됩니다.

AI-AI 위임이 중요한 이유

AI 대 AI 위임의 전략적 중요성은 단순한 비용 절감을 넘어 확장됩니다.

고급 AI 기능의 민주화

Claude 3.7, GPT-4o 등과 같은 강력한 모델이 효과적으로 위임할 수 있도록 함으로써 다음과 같은 이점을 얻을 수 있습니다.

고급 AI 기능을 훨씬 저렴한 비용으로 이용 가능
예산 제약이 있는 조직이 최고 수준의 AI 역량을 활용할 수 있도록 허용
산업 전반에 걸쳐 AI 리소스를 보다 효율적으로 사용할 수 있도록 지원

경제적 자원 최적화

AI 대 AI 위임은 근본적인 경제적 최적화를 나타냅니다.

복잡한 추론, 창의성, 이해력은 최상위 모델에만 국한됩니다.
일상적인 데이터 처리, 추출 및 보다 간단한 작업은 비용 효율적인 모델로 전환됩니다.
전체 시스템은 비용의 일부만으로 최고 수준의 성능을 달성합니다.
API 비용은 예측 불가능한 부채가 아닌 통제된 지출이 됩니다.

지속 가능한 AI 아키텍처

이 접근 방식은 보다 지속 가능한 AI 사용을 촉진합니다.

불필요한 고사양 컴퓨팅 리소스 소모를 줄입니다.
요구 사항에 맞게 기능을 일치시키는 AI에 대한 계층적 접근 방식을 만듭니다.
최고 수준의 모델만으로는 비용이 많이 드는 실험 작업을 허용합니다.
비즈니스 요구 사항에 따라 확장 가능한 AI 통합 접근 방식을 만듭니다.

기술 진화 경로

LLM Gateway는 AI 애플리케이션 아키텍처의 중요한 발전을 나타냅니다.

모놀리식 AI 호출에서 분산형 다중 모델 워크플로로 전환
복잡한 처리 파이프라인의 AI 기반 오케스트레이션 활성화
자체 리소스 사용에 대해 추론할 수 있는 AI 시스템을 위한 기반 구축
지능적인 위임 결정을 내리는 자체 최적화 AI 시스템을 구축합니다.

AI 효율성의 미래

LLM Gateway는 다음과 같은 미래를 지향합니다.

AI 시스템은 자체 리소스 사용을 적극적으로 관리하고 최적화합니다.
더 높은 성능의 모델은 전체 AI 생태계를 위한 지능형 오케스트레이터 역할을 합니다.
AI 워크플로는 점점 더 정교해지고 자체 구성화되고 있습니다.
조직은 비용 효율적인 방식으로 AI 기능의 전체 스펙트럼을 활용할 수 있습니다.

효율적이고 자율 조직화되는 AI 시스템에 대한 이러한 비전은 모든 작업에 단일 모델을 사용하는 현재 패턴을 넘어서는 실용적인 AI 배포의 새로운 전선을 나타냅니다.

건축학

MCP 통합 작동 방식

LLM 게이트웨이는 기본적으로 모델 컨텍스트 프로토콜을 기반으로 구축됩니다.

MCP 서버 코어 : 게이트웨이는 전체 MCP 서버를 구현합니다.
도구 등록 : 모든 기능이 MCP 도구로 노출됩니다.
도구 호출 : Claude 및 기타 AI 에이전트는 이러한 도구를 직접 호출할 수 있습니다.
컨텍스트 전달 : 결과는 MCP의 표준 형식으로 반환됩니다.

이를 통해 Claude 및 기타 MCP 호환 에이전트와의 원활한 통합이 보장됩니다.

구성 요소 다이어그램

┌─────────────┐         ┌───────────────────┐         ┌──────────────┐
│  Claude 3.7 │ ────────► LLM Gateway MCP   │ ────────► LLM Providers│
│   (Agent)   │ ◄──────── Server & Tools    │ ◄──────── (Multiple)   │
└─────────────┘         └───────┬───────────┘         └──────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │  Completion   │  │   Document    │  │  Extraction   │        │
│  │    Tools      │  │    Tools      │  │    Tools      │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │  Optimization │  │  Core MCP     │  │  Analytics    │        │
│  │    Tools      │  │   Server      │  │    Tools      │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │    Cache      │  │    Vector     │  │    Prompt     │        │
│  │   Service     │  │   Service     │  │   Service     │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │  Tournament   │  │    Code       │  │   Multi-Agent │        │
│  │     Tools     │  │  Extraction   │  │  Coordination │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │   RAG Tools   │  │ Local Text    │  │  Meta Tools   │        │
│  │               │  │    Tools      │  │               │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

위임을 위한 요청 흐름

Claude가 LLM Gateway에 작업을 위임하는 경우:

Claude가 MCP 도구 호출 요청을 보냅니다.
게이트웨이는 MCP 프로토콜을 통해 요청을 수신합니다.
적절한 도구가 요청을 처리합니다.
캐싱 서비스는 결과가 이미 캐시되었는지 확인합니다.
캐시되지 않은 경우 최적화 서비스는 적절한 공급자/모델을 선택합니다.
공급자 계층은 선택된 LLM API에 요청을 보냅니다.
응답은 표준화되고 캐시되며 측정항목이 기록됩니다.
MCP 서버는 결과를 Claude에게 반환합니다.

자세한 기능 문서

공급자 통합

다중 공급자 지원 : 다음에 대한 일류 지원:
- OpenAI(GPT-4o-미니, GPT-4o, GPT-4o 미니)
- 인간중심주의(클로드 3.7 시리즈)
- Google(제미니 프로, 제미니 플래시, 제미니 플래시 라이트)
- DeepSeek(DeepSeek-Chat, DeepSeek-Reasoner)
- 새로운 공급자 추가를 위한 확장 가능한 아키텍처
모델 관리 :
- 작업 요구 사항에 따른 자동 모델 선택
- 모델 성능 추적
- 공급자 중단에 대한 대체 메커니즘

비용 최적화

지능형 라우팅 : 다음을 기준으로 모델을 자동으로 선택합니다.
- 작업 복잡성 요구 사항
- 예산 제약
- 성과 우선순위
- 과거 성과 데이터
고급 캐싱 시스템 :
- 다양한 캐싱 전략(정확한 캐싱, 의미적 캐싱, 작업 기반 캐싱)
- 작업 유형별로 구성 가능한 TTL
- 빠른 메모리 내 조회를 통한 영구 캐시
- 캐시 통계 및 비용 절감 추적

문서 처리

스마트 문서 청킹 :
- 다양한 청킹 전략(토큰 기반, 의미적, 구조적)
- 컨텍스트 보존을 위한 오버랩 구성
- 매우 큰 문서를 효율적으로 처리합니다
문서 작업 :
- 요약(구성 가능한 형식 포함)
- 엔티티 추출
- 질문-답변 쌍 생성
- 동시성 제어를 통한 일괄 처리

데이터 추출

구조화된 데이터 추출 :
- 스키마 검증을 통한 JSON 추출
- 테이블 추출(JSON, CSV, 마크다운 형식)
- 키-값 쌍 추출
- 의미론적 스키마 추론

토너먼트 및 벤치마킹

모델 경연대회 :
- 다양한 모델과 구성 간의 경쟁을 실행하세요
- 공급업체 간 코드 생성 기능 비교
- 통계적 성과 보고서 생성
- 과거 분석을 위해 경쟁 결과를 저장하세요
코드 추출 :
- 모델 응답에서 깨끗한 코드 추출
- 추출된 코드 분석 및 검증
- 다양한 프로그래밍 언어 지원

벡터 연산

임베딩 서비스 :
- 효율적인 텍스트 임베딩 생성
- API 비용 절감을 위한 캐싱 내장
- 성능을 위한 일괄 처리
의미 검색 :
- 의미적으로 유사한 콘텐츠 찾기
- 구성 가능한 유사도 임계값
- 빠른 벡터 연산
고급 융합 검색(Marqo) :
- Marqo를 활용하여 키워드와 의미 검색을 결합합니다.
- 키워드와 벡터 관련성 간의 조정 가능한 가중치
- 복잡한 필터링 및 패싯팅 지원

검색 증강 생성(RAG)

문맥적 생성 :
- 관련 검색 정보로 LLM 프롬프트를 증강합니다.
- 사실의 정확성을 높이고 환각을 줄입니다.
- 벡터 검색 및 문서 저장소와 통합
워크플로 통합 :
- 문서 검색과 생성 작업을 원활하게 결합합니다.
- 사용자 정의 가능한 검색 및 생성 전략

로컬 텍스트 처리

오프라인 작업 :
- API 호출 없이 로컬로 실행되는 텍스트 조작 도구를 제공합니다.
- 정리, 포맷팅, 기본 분석 기능이 포함되어 있습니다.
- LLM으로 보내기 전 텍스트 사전 처리 또는 결과 사후 처리에 유용합니다.

메타 작업

내성과 관리 :
- 서버 기능 및 상태를 쿼리하기 위한 도구
- 구성이나 도구 설정을 동적으로 관리하는 기능이 포함될 수 있습니다.
- 더욱 복잡한 에이전트 상호작용과 자체 관리를 용이하게 합니다.

시스템 기능

풍부한 로깅 :
- Rich를 사용한 아름다운 콘솔 출력
- 다양한 작업에 대한 이모티콘 표시기
- 자세한 컨텍스트 정보
- 로그 항목의 성능 측정 항목
스트리밍 지원 :
- 모든 공급자에 걸쳐 일관된 스트리밍 인터페이스
- 토큰별 전달
- 스트리밍 중 비용 추적
건강 모니터링 :
- 엔드포인트 상태 점검(/healthz)
- 리소스 사용 모니터링
- 공급자 가용성 추적
- 오류율 통계
명령줄 인터페이스 :
- 서버 관리를 위한 풍부한 대화형 CLI
- 명령줄에서 직접 도구 호출
- 구성 관리
- 캐시 및 서버 상태 검사

도구 사용 예

이 섹션에서는 MCP 클라이언트(예: Claude 3.7)가 LLM 게이트웨이에서 제공하는 특정 도구를 호출하는 방법을 보여주는 예를 제공합니다. 이 예제에서는 게이트웨이에 연결된 client 라는 이름의 초기화된 mcp.client.Client 인스턴스가 있다고 가정합니다.

기본 완료

선택한 공급업체에서 간단한 텍스트 완성을 받으려면:

response = await client.tools.completion(
    prompt="Write a short poem about a robot learning to dream.",
    provider="openai",  # Or "anthropic", "gemini", "deepseek"
    model="gpt-4o-mini", # Specify the desired model
    max_tokens=100,
    temperature=0.7
)

if response["success"]:
    print(f"Completion: {response['completion']}")
    print(f"Cost: ${response['cost']:.6f}")
else:
    print(f"Error: {response['error']}")

문서 요약

비용 효율적인 모델에 위임하여 텍스트를 요약하려면 다음과 같이 하십시오.

document_text = "... your long document content here ..."

summary_response = await client.tools.summarize_document(
    document=document_text,
    provider="gemini",
    model="gemini-2.0-flash-lite", # Using a cheaper model for summarization
    format="bullet_points", # Options: "paragraph", "bullet_points"
    max_length=150 # Target summary length in tokens (approximate)
)

if summary_response["success"]:
    print(f"Summary:\n{summary_response['summary']}")
    print(f"Cost: ${summary_response['cost']:.6f}")
else:
    print(f"Error: {summary_response['error']}")

엔티티 추출

텍스트에서 특정 유형의 엔터티를 추출하려면:

text_to_analyze = "Apple Inc. announced its quarterly earnings on May 5th, 2024, reporting strong iPhone sales from its headquarters in Cupertino."

entity_response = await client.tools.extract_entities(
    document=text_to_analyze,
    entity_types=["organization", "date", "product", "location"],
    provider="openai",
    model="gpt-4o-mini"
)

if entity_response["success"]:
    print(f"Extracted Entities: {entity_response['entities']}")
    print(f"Cost: ${entity_response['cost']:.6f}")
else:
    print(f"Error: {entity_response['error']}")

최적화된 워크플로 실행

게이트웨이가 각 단계의 모델 선택을 최적화하는 다단계 워크플로를 실행하려면 다음을 수행합니다.

doc_content = "... content for workflow processing ..."

workflow_definition = [
    {
        "name": "Summarize",
        "operation": "summarize_document",
        "provider_preference": "cost", # Prioritize cheaper models
        "params": {"format": "paragraph"},
        "input_from": "original",
        "output_as": "step1_summary"
    },
    {
        "name": "ExtractKeywords",
        "operation": "extract_keywords", # Assuming an extract_keywords tool exists
        "provider_preference": "speed",
        "params": {"count": 5},
        "input_from": "step1_summary",
        "output_as": "step2_keywords"
    }
]

workflow_response = await client.tools.execute_optimized_workflow(
    documents=[doc_content],
    workflow=workflow_definition
)

if workflow_response["success"]:
    print("Workflow executed successfully.")
    print(f"Results: {workflow_response['results']}") # Contains outputs like step1_summary, step2_keywords
    print(f"Total Cost: ${workflow_response['total_cost']:.6f}")
    print(f"Processing Time: {workflow_response['processing_time']:.2f}s")
else:
    print(f"Workflow Error: {workflow_response['error']}")

사용 가능한 도구 나열(메타 도구)

게이트웨이에 현재 등록되어 있고 사용 가능한 도구를 동적으로 검색하려면:

# Assuming a meta-tool for listing capabilities
list_tools_response = await client.tools.list_tools()

if list_tools_response["success"]:
    print("Available Tools:")
    for tool_name, tool_info in list_tools_response["tools"].items():
        print(f"- {tool_name}: {tool_info.get('description', 'No description')}")
        # You might also get parameters, etc.
else:
    print(f"Error listing tools: {list_tools_response['error']}")

실제 사용 사례

AI 에이전트 오케스트레이션

Claude나 다른 고급 AI 에이전트는 LLM Gateway를 사용하여 다음을 수행할 수 있습니다.

일상적인 작업을 저렴한 모델에 위임
대용량 문서를 병렬로 처리
비정형 텍스트에서 정형 데이터 추출
검토 및 개선을 위한 초안 생성

엔터프라이즈 문서 처리

대규모 문서 컬렉션을 효율적으로 처리합니다.

문서를 의미 있는 덩어리로 나누세요
최적 모델에 걸쳐 처리 분산
대규모로 구조화된 데이터 추출
문서 전체에서 의미 검색을 구현합니다.

연구 및 분석

연구팀은 LLM Gateway를 사용하여 다음을 수행할 수 있습니다.

다양한 모델의 출력을 비교합니다
연구 논문을 효율적으로 처리하세요
연구에서 구조화된 정보 추출
토큰 사용량을 추적하고 연구 예산을 최적화하세요

모델 벤치마킹 및 선택

조직은 토너먼트 기능을 사용하여 다음을 수행할 수 있습니다.

다양한 모델 간의 통제된 경쟁을 실행하세요
정량적 성과 지표 생성
모델 선택에 대한 데이터 기반 의사 결정
사용자 정의 모델 평가 프레임워크 구축

보안 고려 사항

LLM 게이트웨이를 배포하고 운영할 때 다음과 같은 보안 측면을 고려하세요.

API 키 관리:
- API 키를 소스 코드에 하드코딩하지 마세요 .
- 환경 변수를 사용합니다(로컬 개발의 경우 .env 파일, 시스템 환경 변수 또는 HashiCorp Vault, AWS Secrets Manager, 프로덕션의 경우 GCP Secret Manager와 같은 비밀 관리 도구).
- .env 파일을 사용하는 경우 해당 파일에 엄격한 파일 권한(게이트웨이를 실행하는 사용자만 읽을 수 있음)이 있는지 확인하세요.
- 주기적으로 키를 교체하고, 손상되었다고 의심되는 키는 즉시 폐기하세요.
네트워크 노출 및 액세스 제어:
- 기본적으로 서버는 127.0.0.1 에 바인딩되어 로컬 연결만 허용합니다. 외부에 공개하려는 경우에만 SERVER_HOST``0.0.0.0 으로 변경하고 적절한 제어가 설정되어 있는지 확인하세요.
- 수신 연결을 처리하려면 역방향 프록시(Nginx, Caddy 등)를 사용하세요 . 이를 통해 TLS/SSL 암호화를 관리하고, 접근 제어(예: IP 허용 목록)를 적용하고, 게이트웨이 수준 인증을 추가할 수 있습니다.
- 호스트 컴퓨터나 네트워크에 방화벽 규칙을 적용하여 신뢰할 수 있는 소스(예: 역방향 프록시나 특정 내부 클라이언트)에서만 SERVER_PORT 에 액세스하도록 제한합니다.
인증 및 권한 부여:
- 게이트웨이 자체에는 사용자 인증 기능이 내장되어 있지 않을 수 있습니다. 액세스 제어는 일반적으로 네트워크 보안(방화벽, VPN)에 의존하며, 경우에 따라 역방향 프록시(예: 기본 인증, OAuth2 프록시)를 통해 인증이 처리될 수도 있습니다.
- 오직 권한이 있는 클라이언트(신뢰할 수 있는 AI 에이전트나 애플리케이션 등)만 게이트웨이 엔드포인트에 도달할 수 있도록 하세요.
속도 제한 및 남용 방지:
- 역방향 프록시 수준에서 속도 제한을 구현하거나 전용 미들웨어를 사용하여 서비스 거부 공격이나 과도한 API 사용(높은 비용이 발생할 수 있음)을 방지합니다.
입력 검증:
- LLM 입력은 일반적으로 텍스트이지만, 도구가 입력을 해석하여 취약점을 유발할 수 있는 경우(예: 도구가 입력을 기반으로 코드를 실행하는 경우) 주의하십시오. 특정 도구의 기능에 적합한 경우 입력을 정제하거나 검증하십시오.
종속성 보안:
- 정기적으로 종속성을 업데이트합니다( uv pip install --upgrade ... 또는 이와 유사한 명령어). 이를 통해 타사 라이브러리의 알려진 취약점을 패치합니다.
- 취약한 종속성을 식별하기 위해 보안 스캐닝 도구( pip-audit 또는 GitHub Dependabot 알림 등)를 사용하는 것을 고려하세요.
벌채 반출:
- DEBUG 수준 로깅은 민감한 정보를 포함하여 전체 프롬프트와 응답을 기록할 수 있습니다. LOG_LEVEL 환경에 맞게 적절히 설정하고 로그 파일에 적절한 권한이 있는지 확인하세요.

특허

이 프로젝트는 MIT 라이선스에 따라 라이선스가 부여되었습니다. 자세한 내용은 라이선스 파일을 참조하세요.

감사의 말

API 기반을 위한 모델 컨텍스트 프로토콜
아름다운 터미널 출력을 위한 Rich
데이터 검증을 위한 Pydantic
빠르고 안정적인 Python 패키지 관리를 위한 uv
API를 통해 모델을 제공하는 모든 LLM 공급자

Integrations