Servidor MCP de puerta de enlace LLM

Un servidor de Protocolo de Contexto de Modelo (MCP) que permite la delegación inteligente de agentes de IA de alta capacidad a LLM rentables

Primeros pasos • Características principales • Ejemplos de uso • Arquitectura •

¿Qué es LLM Gateway?

LLM Gateway es un servidor nativo de MCP que permite la delegación inteligente de tareas desde agentes de IA avanzados como Claude 3.7 Sonnet a modelos más rentables como Gemini Flash 2.0 Lite. Proporciona una interfaz unificada para múltiples proveedores de Modelos de Lenguaje Grandes (LLM), optimizando al mismo tiempo el coste, el rendimiento y la calidad.

La visión: Optimización de recursos impulsada por IA

En esencia, LLM Gateway representa un cambio fundamental en la forma en que interactuamos con los sistemas de IA. En lugar de usar un único y costoso modelo para todas las tareas, permite una jerarquía inteligente donde:

Los modelos avanzados como Claude 3.7 se centran en el razonamiento de alto nivel, la orquestación y las tareas complejas.
Los modelos rentables gestionan tareas rutinarias de procesamiento, extracción y mecánicas.
El sistema en general logra un rendimiento cercano al máximo nivel a una fracción del costo.

Este enfoque refleja cómo funcionan las organizaciones humanas: los especialistas manejan decisiones complejas mientras delegan tareas rutinarias a otros con las habilidades adecuadas para esas tareas específicas.

Arquitectura nativa MCP

El servidor se basa en el Protocolo de Contexto de Modelo (MCP) , lo que lo hace especialmente diseñado para funcionar con agentes de IA como Claude. Toda la funcionalidad se expone mediante herramientas MCP, a las que estos agentes pueden llamar directamente, lo que crea un flujo de trabajo fluido para la delegación entre IA.

Caso de uso principal: Delegación de tareas del agente de IA

El objetivo principal de diseño de LLM Gateway es permitir que agentes de IA sofisticados como Claude 3.7 Sonnet deleguen tareas de forma inteligente a modelos menos costosos:

                          delegates to
┌─────────────┐ ────────────────────────► ┌───────────────────┐         ┌──────────────┐
│ Claude 3.7  │                           │   LLM Gateway     │ ───────►│ Gemini Flash │
│   (Agent)   │ ◄──────────────────────── │    MCP Server     │ ◄───────│ DeepSeek     │
└─────────────┘      returns results      └───────────────────┘         │ GPT-4o-mini  │
                                                                        └──────────────┘

Ejemplo de flujo de trabajo:

Claude identifica que es necesario resumir un documento (una operación costosa con Claude)
Claude delega esta tarea a LLM Gateway a través de herramientas MCP
LLM Gateway dirige la tarea de resumen a Gemini Flash (10-20 veces más económico que Claude)
El resumen se devuelve a Claude para un razonamiento y toma de decisiones de mayor nivel.
Claude puede entonces centrar sus capacidades en tareas que realmente requieren su inteligencia.

Este patrón de delegación puede ahorrar entre un 70 y un 90 % en costos de API manteniendo la calidad de salida.

¿Por qué utilizar LLM Gateway?

Delegación de tareas de IA a IA

El caso de uso más poderoso es permitir que los agentes de IA avanzados deleguen tareas rutinarias a modelos más económicos:

Haga que Claude 3.7 utilice GPT-4o-mini para el resumen inicial del documento
Deje que Claude use la linterna Gemini 2.0 para la extracción y transformación de datos
Permitir que Claude organice un flujo de trabajo de varias etapas entre diferentes proveedores
Permitir que Claude elija el modelo adecuado para cada subtarea específica

💰 Optimización de costos

Los costos de API para modelos avanzados pueden ser considerables. LLM Gateway ayuda a reducir costos mediante:

Dirigir las tareas adecuadas a modelos más económicos (por ejemplo, $0,01/1000 tokens frente a $0,15/1000 tokens)
Implementación de almacenamiento en caché avanzado para evitar llamadas API redundantes
Seguimiento y optimización de costes entre proveedores
Permitir decisiones de enrutamiento de tareas teniendo en cuenta los costos

Abstracción del proveedor

Evite el bloqueo del proveedor con una interfaz unificada:

API estándar para OpenAI, Anthropic (Claude), Google (Gemini) y DeepSeek
Manejo consistente de parámetros y formato de respuesta
Capacidad de cambiar de proveedor sin cambiar el código de la aplicación
Protección contra interrupciones y limitaciones específicas del proveedor

Procesamiento de documentos a escala

Procese documentos grandes de manera eficiente:

Dividir los documentos en fragmentos semánticamente significativos
Procesar fragmentos en paralelo en múltiples modelos
Extraer datos estructurados de texto no estructurado
Generar resúmenes y perspectivas a partir de textos extensos

Características principales

Integración del protocolo MCP

Servidor MCP nativo : basado en el protocolo de contexto de modelo para la integración de agentes de IA
Marco de herramientas MCP : toda la funcionalidad expuesta a través de herramientas MCP estandarizadas
Composición de herramientas : Las herramientas se pueden combinar para flujos de trabajo complejos
Descubrimiento de herramientas : Soporte para listado de herramientas y descubrimiento de capacidades

Delegación inteligente de tareas

Enrutamiento de tareas : analizar tareas y dirigirlas a modelos apropiados
Selección del proveedor : elija al proveedor según los requisitos de la tarea
Equilibrio costo-rendimiento : optimice el costo, la calidad o la velocidad
Seguimiento de la delegación : supervise los patrones y resultados de la delegación

Almacenamiento en caché avanzado

Almacenamiento en caché multinivel : múltiples estrategias de almacenamiento en caché:
- Almacenamiento en caché de coincidencias exactas
- Almacenamiento en caché de similitud semántica
- Almacenamiento en caché consciente de las tareas
Caché persistente : persistencia basada en disco con acceso rápido a la memoria
Análisis de caché : seguimiento de ahorros y tasas de aciertos

Herramientas de documentos

Fragmentación inteligente : múltiples estrategias de fragmentación:
- Fragmentación basada en tokens
- Detección de límites semánticos
- Análisis estructural
Operaciones de documentos :
- Resumen
- Extracción de entidades
- Generación de preguntas
- Procesamiento por lotes

Extracción de datos estructurados

Extracción de JSON : extraiga JSON estructurado con validación de esquema
Extracción de tablas : Extraer tablas en múltiples formatos
Extracción de clave-valor : extrae pares clave-valor del texto
Inferencia de esquemas semánticos : generar esquemas a partir de texto

Modo torneo

Competiciones de código y texto : Soporte para ejecutar competiciones de estilo torneo
Modelos múltiples : compare resultados de diferentes modelos simultáneamente
Métricas de rendimiento : evaluar y realizar un seguimiento del rendimiento del modelo
Almacenamiento de resultados : conserva los resultados del torneo para un análisis posterior

Operaciones vectoriales avanzadas

Búsqueda semántica : encuentre contenido semánticamente similar en todos los documentos
Almacenamiento vectorial : almacenamiento y recuperación eficientes de incrustaciones vectoriales
Búsqueda híbrida : combina funciones de búsqueda semántica y por palabras clave
Procesamiento por lotes : procese de manera eficiente grandes conjuntos de datos

Ejemplos de uso

Claude utiliza LLM Gateway para el análisis de documentos

Este ejemplo muestra cómo Claude puede usar LLM Gateway para procesar un documento delegando tareas a modelos más económicos:

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())

Comparación de múltiples proveedores para la toma de decisiones

# 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']}")

Flujo de trabajo optimizado en costos

# 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}")

Fragmentación de documentos

Para dividir un documento grande en fragmentos más pequeños y manejables:

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']}")

Finalización de múltiples proveedores

Para obtener finalizaciones para el mismo mensaje de varios proveedores/modelos simultáneamente para comparar:

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']}")

Extracción de datos estructurados (JSON)

Para extraer información del texto en un esquema JSON específico:

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']}")

Consulta de recuperación-generación aumentada (RAG)

Para hacer una pregunta usando RAG, donde el sistema recupera el contexto relevante antes de generar una respuesta (asumiendo que se han indexado los documentos relevantes):

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']}")

Búsqueda fusionada (palabra clave + semántica)

Para realizar una búsqueda híbrida combinando la relevancia de palabras clave y la similitud semántica utilizando 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']}")

Procesamiento de texto local

Para realizar operaciones de texto locales sin conexión sin llamar a una API LLM:

# 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']}")

Organización de un torneo de modelos

Para comparar los resultados de varios modelos en una tarea específica (por ejemplo, generación de código):

# 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']}")

(Se pueden agregar más ejemplos de herramientas aquí...)

Empezando

Instalación

# 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]"

Configuración del entorno

Crea un archivo .env con tus claves API:

# 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

Ejecución del servidor

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

# Or with Docker
docker compose up

Una vez en ejecución, el servidor estará disponible en http://localhost:8013 .

Configuración avanzada

Si bien el archivo .env es conveniente para la configuración básica, LLM Gateway ofrece opciones de configuración más detalladas administradas principalmente a través de variables de entorno.

Configuración del servidor

SERVER_HOST : (Predeterminado: 127.0.0.1 ) La interfaz de red en la que escucha el servidor. Use 0.0.0.0 para escuchar en todas las interfaces (necesario para Docker o acceso externo).
SERVER_PORT : (Predeterminado: 8013 ) El puerto en el que escucha el servidor.
API_PREFIX : (Predeterminado: / ) El prefijo de URL para los puntos finales de la API.

Configuración de registro

LOG_LEVEL : (Predeterminado: INFO ) Controla el nivel de detalle de los registros. Opciones: DEBUG , INFO , WARNING , ERROR , CRITICAL .
USE_RICH_LOGGING : (Predeterminado: true ) Utiliza la biblioteca Rich para registros de consola con formato y colores. Establézcala en false para registros de texto sin formato (mejor para la redirección de archivos o algunos sistemas de agregación de registros).
LOG_FORMAT : (opcional) especifique una cadena de formato de registro personalizado.
LOG_TO_FILE : (opcional, por ejemplo, gateway.log ) Ruta a un archivo donde también se deben escribir los registros.

Configuración de caché

CACHE_ENABLED : (Predeterminado: true ) Habilita o deshabilita el almacenamiento en caché globalmente.
CACHE_TTL : (Predeterminado: 86400 segundos, es decir, 24 horas) Tiempo de vida predeterminado para los elementos almacenados en caché. Es posible que algunas herramientas lo anulen.
CACHE_TYPE : (Predeterminado: memory ) El tipo de caché de backend. Las opciones pueden incluir memory , redis y diskcache . ( Nota: Consulte la implementación actual para conocer los tipos admitidos ).
CACHE_MAX_SIZE : (opcional) Número máximo de elementos o tamaño de memoria para el caché.
REDIS_URL : (Obligatorio si CACHE_TYPE=redis ) URL de conexión para el servidor de caché Redis (por ejemplo, redis://localhost:6379/0 ).

Tiempos de espera y reintentos del proveedor

PROVIDER_TIMEOUT : (Predeterminado: 120 segundos) Tiempo de espera predeterminado para solicitudes a las API del proveedor LLM.
PROVIDER_MAX_RETRIES : (Predeterminado: 3 ) Número predeterminado de reintentos para solicitudes de proveedor fallidas (por ejemplo, debido a problemas temporales de red o límites de velocidad).
Se pueden configurar tiempos de espera y reintentos de proveedores específicos a través de variables dedicadas como OPENAI_TIMEOUT , ANTHROPIC_MAX_RETRIES , etc. ( Nota: Verifique la implementación actual ).

Configuración específica de la herramienta

Algunas herramientas pueden tener sus propias variables de entorno específicas para la configuración (p. ej., MARQO_URL para búsqueda fusionada, parámetros de fragmentación predeterminados). Consulte la documentación o el código fuente de cada herramienta.

Asegúrese siempre de que las variables de entorno estén configuradas correctamente antes de iniciar el servidor. Los cambios suelen requerir reiniciar el servidor.

Consideraciones de implementación

Si bien ejecutar el servidor directamente con python o docker compose up es adecuado para el desarrollo y las pruebas, considere lo siguiente para implementaciones más sólidas o de producción:

1. Ejecución como servicio en segundo plano

Para garantizar que la puerta de enlace funcione de forma continua y se reinicie automáticamente en caso de falla o reinicio del servidor, utilice un administrador de procesos:

systemd (Linux): Crea un archivo de unidad de servicio (p. ej., /etc/systemd/system/llm-gateway.service ) para gestionar el proceso. Esto permite comandos como sudo systemctl start|stop|restart|status llm-gateway .
supervisor : Un sistema de control de procesos popular escrito en Python. Configure supervisord para supervisar y controlar el proceso de puerta de enlace.
Políticas de reinicio de Docker: si usa Docker (independiente o Compose), configure las políticas de reinicio adecuadas (por ejemplo, unless-stopped o always ) en el comando docker run o en el archivo docker-compose.yml .

2. Uso de un proxy inverso (Nginx/Caddy/Apache)

Se recomienda encarecidamente colocar un proxy inverso delante de LLM Gateway:

Terminación HTTPS/SSL: el proxy puede manejar certificados SSL (por ejemplo, usando Let's Encrypt con Caddy o Certbot con Nginx/Apache), cifrando el tráfico entre los clientes y el proxy.
Equilibrio de carga: si necesita ejecutar varias instancias de la puerta de enlace para lograr alta disponibilidad o rendimiento, el proxy puede distribuir el tráfico entre ellas.
Enrutamiento de ruta: asigna rutas externas (por ejemplo, https://api.yourdomain.com/llm-gateway/ ) al servidor de puerta de enlace interno ( http://localhost:8013 ).
Encabezados de seguridad: agregue encabezados de seguridad importantes (como CSP, HSTS).
Almacenamiento en búfer/caché: algunos servidores proxy ofrecen capacidades adicionales de almacenamiento en búfer o caché de solicitudes y respuestas.

Ejemplo de bloque location de Nginx (simplificado):

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. Orquestación de contenedores (Kubernetes/Swarm)

Si se implementa en un entorno de contenedores:

Comprobaciones de estado: implemente y configure puntos finales de comprobación de estado (por ejemplo, /healthz mencionado anteriormente) en sus manifiestos de implementación para que el orquestador pueda monitorear el estado del servicio.
Configuración: utilice ConfigMaps y Secrets (Kubernetes) o mecanismos equivalentes para administrar las variables de entorno y las claves API de forma segura, en lugar de codificarlas en imágenes o confiar únicamente en archivos .env .
Límites de recursos: defina solicitudes y límites de memoria y CPU adecuados para el contenedor de puerta de enlace a fin de garantizar un rendimiento estable y evitar la falta de recursos.
Descubrimiento de servicios: utilice los mecanismos de descubrimiento de servicios del orquestador en lugar de codificar direcciones IP o nombres de host.

4. Asignación de recursos

Asegúrese de que la máquina host o el contenedor tengan suficiente RAM , especialmente si se utiliza almacenamiento en caché en memoria o se procesan documentos o solicitudes grandes.
Supervise el uso de la CPU , especialmente bajo carga pesada o cuando múltiples operaciones complejas se ejecutan simultáneamente.

Ahorro de costes con la delegación

El uso de LLM Gateway para la delegación puede generar importantes ahorros de costos:

Tarea	Claude 3.7 Direct	Delegado a LLM más barato	Ahorros
Resumen de un documento de 100 páginas	$4.50	$0.45 (Flash Géminis)	90%
Extrayendo datos de 50 registros	$2.25	$0,35 (GPT-4o-mini)	84%
Generando 20 ideas de contenido	$0.90	$0.12 (Búsqueda profunda)	87%
Procesando 1.000 consultas de clientes	$45.00	$7.50 (Delegación mixta)	83%

Estos ahorros se logran manteniendo resultados de alta calidad al permitir que Claude se concentre en el razonamiento y la orquestación de alto nivel mientras delega tareas mecánicas a modelos rentables.

Por qué es importante la delegación de IA a IA

La importancia estratégica de la delegación de IA a IA se extiende más allá del simple ahorro de costos:

Democratizando las capacidades avanzadas de IA

Al permitir que modelos potentes como Claude 3.7, GPT-4o y otros deleguen de manera efectiva, logramos lo siguiente:

Haga que las capacidades avanzadas de IA sean accesibles a una fracción del costo
Permitir que las organizaciones con limitaciones presupuestarias aprovechen las capacidades de IA de primer nivel
Permitir un uso más eficiente de los recursos de IA en toda la industria

Optimización de recursos económicos

La delegación de IA a IA representa una optimización económica fundamental:

El razonamiento complejo, la creatividad y la comprensión están reservados para los modelos de primer nivel.
El procesamiento rutinario de datos, la extracción y las tareas más simples pasan a modelos rentables.
El sistema en general logra un rendimiento cercano al máximo nivel a una fracción del costo.
Los costos de API se convierten en un gasto controlado en lugar de un pasivo impredecible

Arquitectura de IA sostenible

Este enfoque promueve un uso más sostenible de la IA:

Reduce el consumo innecesario de recursos computacionales de alta gama
Crea un enfoque escalonado para la IA que adapta las capacidades a los requisitos.
Permite trabajos experimentales que serían prohibitivamente costosos solo con modelos de primer nivel
Crea un enfoque escalable para la integración de IA que puede crecer con las necesidades comerciales.

Camino de evolución técnica

LLM Gateway representa una evolución importante en la arquitectura de aplicaciones de IA:

Pasar de llamadas de IA monolíticas a flujos de trabajo distribuidos y multimodelo
Habilitación de la orquestación impulsada por IA de canales de procesamiento complejos
Creación de una base para sistemas de IA que puedan razonar sobre su propio uso de recursos
Desarrollar sistemas de IA autooptimizables que tomen decisiones de delegación inteligentes

El futuro de la eficiencia de la IA

LLM Gateway apunta hacia un futuro donde:

Los sistemas de IA gestionan y optimizan activamente su propio uso de recursos
Los modelos de mayor capacidad sirven como orquestadores inteligentes para ecosistemas de IA completos
Los flujos de trabajo de IA se vuelven cada vez más sofisticados y autoorganizados
Las organizaciones pueden aprovechar todo el espectro de capacidades de IA de formas rentables

Esta visión de sistemas de IA eficientes y autoorganizados representa la próxima frontera en la implementación práctica de IA, yendo más allá del patrón actual de utilizar modelos únicos para cada tarea.

Arquitectura

Cómo funciona la integración de MCP

LLM Gateway está construido de forma nativa sobre el Protocolo de Contexto de Modelo:

Núcleo del servidor MCP : la puerta de enlace implementa un servidor MCP completo
Registro de herramientas : todas las capacidades se exponen como herramientas MCP
Invocación de herramientas : Claude y otros agentes de IA pueden invocar directamente estas herramientas
Paso de contexto : los resultados se devuelven en el formato estándar de MCP

Esto garantiza una integración perfecta con Claude y otros agentes compatibles con MCP.

Diagrama de componentes

┌─────────────┐         ┌───────────────────┐         ┌──────────────┐
│  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      │  │               │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Flujo de solicitud de delegación

Cuando Claude delega una tarea a LLM Gateway:

Claude envía una solicitud de invocación de la herramienta MCP
El Gateway recibe la solicitud a través del protocolo MCP
La herramienta adecuada procesa la solicitud.
El servicio de almacenamiento en caché comprueba si el resultado ya está almacenado en caché.
Si no se almacena en caché, el servicio de optimización selecciona el proveedor/modelo adecuado
La capa de proveedor envía la solicitud a la API LLM seleccionada
La respuesta se estandariza, se almacena en caché y se registran las métricas.
El servidor MCP devuelve el resultado a Claude

Documentación detallada de funciones

Integración de proveedores

Soporte multiproveedor : Soporte de primera clase para:
- OpenAI (GPT-4o-mini, GPT-4o, GPT-4o mini)
- Antrópico (serie Claude 3.7)
- Google (Gemini Pro, Gemini Flash, Gemini Flash Light)
- DeepSeek (Chat de DeepSeek, Razonamiento de DeepSeek)
- Arquitectura extensible para agregar nuevos proveedores
Gestión de modelos :
- Selección automática de modelos según los requisitos de la tarea
- Seguimiento del rendimiento del modelo
- Mecanismos de respaldo ante interrupciones del proveedor

Optimización de costos

Enrutamiento inteligente : selecciona automáticamente modelos en función de:
- Requisitos de complejidad de la tarea
- Restricciones presupuestarias
- Prioridades de desempeño
- Datos históricos de rendimiento
Sistema de almacenamiento en caché avanzado :
- Múltiples estrategias de almacenamiento en caché (exacta, semántica, basada en tareas)
- TTL configurable por tipo de tarea
- Caché persistente con búsqueda rápida en memoria
- Estadísticas de caché y seguimiento de ahorro de costes

Procesamiento de documentos

Fragmentación inteligente de documentos :
- Múltiples estrategias de fragmentación (basadas en tokens, semánticas, estructurales)
- Configuración de superposición para la preservación del contexto
- Maneja documentos muy grandes de manera eficiente
Operaciones de documentos :
- Resumen (con formatos configurables)
- Extracción de entidades
- Generación de pares de preguntas y respuestas
- Procesamiento por lotes con control de concurrencia

Extracción de datos

Extracción de datos estructurados :
- Extracción de JSON con validación de esquema
- Extracción de tablas (formatos JSON, CSV y Markdown)
- Extracción de pares clave-valor
- Inferencia de esquemas semánticos

Torneo y evaluación comparativa

Concursos de modelos :
- Realizar competiciones entre diferentes modelos y configuraciones.
- Comparar las capacidades de generación de código entre proveedores
- Generar informes de rendimiento estadístico
- Resultados de la competencia en la tienda para análisis histórico
Extracción de código :
- Extraer código limpio de las respuestas del modelo
- Analizar y validar el código extraído
- Soporte para múltiples lenguajes de programación

Operaciones vectoriales

Servicio de incrustación :
- Generación eficiente de incrustaciones de texto
- Incorporación de almacenamiento en caché para reducir los costos de API
- Procesamiento por lotes para mejorar el rendimiento
Búsqueda semántica :
- Encuentra contenido semánticamente similar
- Umbrales de similitud configurables
- Operaciones vectoriales rápidas
Búsqueda avanzada fusionada (Marqo) :
- Aprovecha Marqo para la búsqueda combinada de palabras clave y semántica
- Ponderación ajustable entre relevancia de palabras clave y vector
- Admite filtrado y facetado complejos

Generación aumentada por recuperación (RAG)

Generación contextual :
- Aumenta las indicaciones de LLM con información recuperada relevante
- Mejora la precisión de los hechos y reduce las alucinaciones.
- Se integra con la búsqueda de vectores y almacenes de documentos.
Integración del flujo de trabajo :
- Combine sin problemas la recuperación de documentos con las tareas de generación
- Estrategias de recuperación y generación personalizables

Procesamiento de texto local

Operaciones fuera de línea :
- Proporciona herramientas para la manipulación de texto que se ejecutan localmente, sin llamadas API
- Incluye funciones de limpieza, formato y análisis básico.
- Útil para preprocesar texto antes de enviarlo a LLM o para posprocesar resultados.

Metaoperaciones

Introspección y gestión :
- Herramientas para consultar las capacidades y el estado del servidor
- Puede incluir funciones para administrar configuraciones o ajustes de herramientas de forma dinámica.
- Facilita interacciones más complejas entre agentes y la autogestión.

Características del sistema

Registro enriquecido :
- Hermosa salida de consola con Rich
- Indicadores emoji para diferentes operaciones
- Información de contexto detallada
- Métricas de rendimiento en las entradas de registro
Soporte de transmisión :
- Interfaz de transmisión consistente entre todos los proveedores
- Entrega token por token
- Seguimiento de costes durante la transmisión
Monitoreo de la salud :
- Comprobaciones del estado del punto final (/healthz)
- Monitoreo del uso de recursos
- Seguimiento de la disponibilidad del proveedor
- Estadísticas de tasa de error
Interfaz de línea de comandos :
- CLI interactiva enriquecida para la gestión del servidor
- Invocación directa de herramientas desde la línea de comandos
- Gestión de la configuración
- Inspección del estado de la caché y del servidor

Ejemplos de uso de herramientas

Esta sección proporciona ejemplos de cómo un cliente MCP (como Claude 3.7) invocaría herramientas específicas proporcionadas por la puerta de enlace LLM. Estos ejemplos asumen que tiene una instancia inicializada mcp.client.Client llamada client conectada a la puerta de enlace.

Finalización básica

Para obtener una finalización de texto simple de un proveedor elegido:

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']}")

Resumen del documento

Para resumir un fragmento de texto, delegando potencialmente a un modelo rentable:

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']}")

Extracción de entidades

Para extraer tipos específicos de entidades del texto:

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']}")

Ejecución de un flujo de trabajo optimizado

Para ejecutar un flujo de trabajo de varios pasos donde la puerta de enlace optimiza la selección de modelos para cada paso:

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']}")

Listado de herramientas disponibles (Metaherramienta)

Para descubrir dinámicamente las herramientas actualmente registradas y disponibles en la puerta de enlace:

# 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']}")

Casos de uso del mundo real

Orquestación de agentes de IA

Claude u otros agentes de IA avanzados pueden usar LLM Gateway para:

Delegar tareas rutinarias a modelos más económicos
Procesar documentos grandes en paralelo
Extraer datos estructurados de texto no estructurado
Generar borradores para revisión y mejora

Procesamiento de documentos empresariales

Procese grandes colecciones de documentos de manera eficiente:

Divida los documentos en fragmentos significativos
Distribuir el procesamiento entre modelos óptimos
Extraer datos estructurados a escala
Implementar la búsqueda semántica en todos los documentos

Investigación y análisis

Los equipos de investigación pueden utilizar LLM Gateway para:

Comparar resultados de diferentes modelos
Procesar artículos de investigación de manera eficiente
Extraer información estructurada de los estudios
Realice un seguimiento del uso de tokens y optimice los presupuestos de investigación

Evaluación comparativa y selección de modelos

Las organizaciones pueden utilizar las funciones del torneo para:

Realizar competiciones controladas entre diferentes modelos
Generar métricas de rendimiento cuantitativas
Tome decisiones basadas en datos sobre la selección de modelos
Cree marcos de evaluación de modelos personalizados

Consideraciones de seguridad

Al implementar y operar LLM Gateway, tenga en cuenta los siguientes aspectos de seguridad:

Gestión de claves API:
- Nunca codifique claves API en su código fuente.
- Utilice variables de entorno (archivo .env para desarrollo local, variables de entorno del sistema o herramientas de gestión de secretos como HashiCorp Vault, AWS Secrets Manager, GCP Secret Manager para producción).
- Asegúrese de que el archivo .env (si se utiliza) tenga permisos de archivo estrictos (legibles solo por el usuario que ejecuta la puerta de enlace).
- Rote las claves periódicamente y revoque inmediatamente cualquier clave sospechosa de estar comprometida.
Exposición a la red y control de acceso:
- De forma predeterminada, el servidor se vincula a 127.0.0.1 y solo permite conexiones locales. Cambie SERVER_HOST a 0.0.0.0 únicamente si pretende exponerlo externamente y asegúrese de que existan los controles adecuados.
- Utilice un proxy inverso (Nginx, Caddy, etc.) para gestionar las conexiones entrantes. Esto le permite gestionar el cifrado TLS/SSL, aplicar controles de acceso (p. ej., lista de direcciones IP permitidas) y, potencialmente, añadir autenticación a nivel de puerta de enlace.
- Utilice reglas de firewall en la máquina host o la red para restringir el acceso a SERVER_PORT solo desde fuentes confiables (como el proxy inverso o clientes internos específicos).
Autenticación y autorización:
- Es posible que la puerta de enlace no cuente con autenticación de usuarios integrada. El control de acceso suele depender de la seguridad de la red (cortafuegos, VPN) y, potencialmente, de la autenticación gestionada por un proxy inverso (p. ej., autenticación básica o proxy OAuth2).
- Asegúrese de que solo los clientes autorizados (como sus aplicaciones o agentes de IA de confianza) puedan llegar al punto final de la puerta de enlace.
Limitación de velocidad y prevención de abusos:
- Implemente la limitación de velocidad a nivel de proxy inverso o utilice middleware dedicado para evitar ataques de denegación de servicio o uso excesivo de API (lo que puede generar altos costos).
Validación de entrada:
- Aunque las entradas de LLM suelen ser texto, tenga cuidado si alguna herramienta las interpreta de forma que puedan generar vulnerabilidades (por ejemplo, si una herramienta ejecuta código basándose en la entrada). Corrija o valide las entradas cuando corresponda para la función específica de la herramienta.
Seguridad de dependencia:
- Actualice periódicamente las dependencias ( uv pip install --upgrade ... o similar) para corregir vulnerabilidades conocidas en bibliotecas de terceros.
- Considere utilizar herramientas de escaneo de seguridad (como pip-audit o alertas de GitHub Dependabot) para identificar dependencias vulnerables.
Explotación florestal:
- Tenga en cuenta que el registro de nivel DEBUG podría registrar solicitudes y respuestas completas, que podrían incluir información confidencial. Configure LOG_LEVEL según su entorno y asegúrese de que los archivos de registro tengan los permisos adecuados.

Licencia

Este proyecto está licenciado bajo la licencia MIT: consulte el archivo de LICENCIA para obtener más detalles.

Expresiones de gratitud

Protocolo de contexto del modelo para la base de la API
Rico para una hermosa salida de terminal
Pydantic para la validación de datos
uv para una gestión rápida y fiable de paquetes de Python
Todos los proveedores de LLM que ponen a disposición sus modelos a través de API

Integrations