mcp-agent-kit

un SDK completo e intuitivo para construir servidores MCP, agentes MCP e integraciones con LLM (OpenAI, Claude, Gemini) con el mínimo esfuerzo. Abstrae toda la complejidad del protocolo MCP, proporciona un agente inteligente con enrutamiento automático de modelos e incluye un cliente universal para APIs externas, todo a través de una única interfaz simple y potente. Perfecto para chatbots, automatización empresarial, integraciones de sistemas internos y desarrollo rápido de ecosistemas basados en MCP.

GitHub

Prueba este MCPPatrocinado

Documentación

mcp-agent-kit

Orquesta servidores MCP y construye agentes de IA en TypeScript — en tu aplicación, no en tu infraestructura

Conecta tu agente a varios servidores MCP en tres líneas — sin gateway, sin proxy, sin contenedor:

const mcp = await connectMCP({
  servers: {
    files: { command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "./"] },
    github: { url: "https://mcp.example.com/mcp" },
  },
});

const agent = createAgent({ provider: "openai" });
agent.use(mcp);

const answer = await agent.chat("Summarise the open issues into notes.md");

mcp-agent-kit es un paquete de TypeScript para trabajar con MCP desde dentro de tu aplicación:

🎛️ Orquestador MCP — conéctate a muchos servidores MCP, agrega y filtra sus herramientas
🔍 CLI inspect — valida las herramientas de cualquier servidor MCP sin escribir código
🔌 Servidores MCP — publica tus propias herramientas a través de stdio o HTTP Streamable
🤖 Agentes de IA con ejecución automática de herramientas en cuatro proveedores de LLM
🧠 Enrutadores Inteligentes para enrutamiento multi-LLM
💬 Chatbots con memoria de conversación
🌐 Ayudantes de API con reintentos y tiempo de espera

Características

En proceso: un npm install, no otro servicio que desplegar
Bucle de herramientas incluido: las herramientas se ejecutan y sus resultados se devuelven al modelo
Filtrado de herramientas: los globs de permitir/denegar evitan que 60 herramientas abulten el prompt
Aislamiento de fallos: un servidor caído degrada el conjunto de herramientas, no al agente
Multi-Proveedor: OpenAI, Anthropic, Gemini, Ollama
Seguridad de tipos: soporte completo de TypeScript con autocompletado
Documentación verificada: cada ejemplo en esta página se compila en CI

Instalación

npm install mcp-agent-kit

Inicio Rápido

Crear un Agente de IA (¡1 línea!)

import { createAgent } from "mcp-agent-kit";

const agent = createAgent({ provider: "openai" });
const response = await agent.chat("Hello!");
console.log(response.content);

Crear un Servidor MCP (¡1 función!)

import { createMCPServer } from "mcp-agent-kit";

const server = await createMCPServer({
  name: "my-server",
  tools: [
    {
      name: "get_weather",
      description: "Get weather for a location",
      inputSchema: {
        type: "object",
        properties: {
          location: { type: "string" },
        },
      },
      handler: async ({ location }) => {
        return `Weather in ${location}: Sunny, 72°F`;
      },
    },
  ],
});

await server.start();

Crear un Chatbot con Memoria

import { createChatbot, createAgent } from "mcp-agent-kit";

const bot = createChatbot({
  agent: createAgent({ provider: "openai" }),
  system: "You are a helpful assistant",
  maxHistory: 10,
});

await bot.chat("Hi, my name is John");
await bot.chat("What is my name?"); // Remembers context!

Documentación

Agentes de IA

Crea agentes inteligentes que trabajan con múltiples proveedores de LLM.

Uso Básico

import { createAgent } from "mcp-agent-kit";

const agent = createAgent({
  provider: "openai",
  model: "gpt-4o",
  temperature: 0.7,
  maxTokens: 2000,
});

const response = await agent.chat("Explain TypeScript");
console.log(response.content);

Proveedores Soportados

Proveedor	Modelos	Clave API Requerida
OpenAI	GPT-4o, GPT-4, serie o	✅ Sí
Anthropic	Claude Opus 5, Sonnet 5	✅ Sí
Gemini	Gemini 2.0+	✅ Sí
Ollama	Modelos locales	❌ No

Con Herramientas (Llamada de Funciones)

const agent = createAgent({
  provider: "openai",
  tools: [
    {
      name: "calculate",
      description: "Perform calculations",
      parameters: {
        type: "object",
        properties: {
          operation: { type: "string", enum: ["add", "subtract"] },
          a: { type: "number" },
          b: { type: "number" },
        },
        required: ["operation", "a", "b"],
      },
      handler: async ({ operation, a, b }) => {
        return operation === "add" ? a + b : a - b;
      },
    },
  ],
});

const response = await agent.chat("What is 15 + 27?");

Con Prompt de Sistema

const agent = createAgent({
  provider: "anthropic",
  system: "You are an expert Python developer. Always provide code examples.",
});

Llamada Inteligente de Herramientas

La Llamada Inteligente de Herramientas añade fiabilidad y rendimiento a la ejecución de herramientas con reintento automático, tiempo de espera y caché.

Configuración Básica

const agent = createAgent({
  provider: "openai",
  toolConfig: {
    forceToolUse: true,      // Force model to use tools
    maxRetries: 3,           // Retry up to 3 times on failure
    toolTimeout: 30000,      // 30 second timeout
    onToolNotCalled: "retry", // Action when tool not called
  },
  tools: [...],
});

Con Caché

const agent = createAgent({
  provider: "openai",
  toolConfig: {
    cacheResults: {
      enabled: true,
      ttl: 300000,    // Cache for 5 minutes
      maxSize: 100,   // Store up to 100 results
    },
  },
  tools: [...],
});

Ejecución Directa de Herramientas

// Execute a tool directly with retry and caching
const result = await agent.executeTool("get_weather", {
  location: "San Francisco, CA",
});

Opciones de Configuración

Opción	Tipo	Predeterminado	Descripción
`forceToolUse`	boolean	false	Fuerza al modelo a usar herramientas cuando están disponibles
`maxRetries`	number	3	Intentos máximos de reintento ante fallo de herramienta
`onToolNotCalled`	string	"retry"	Acción cuando la herramienta no se llama: "retry", "error", "warn", "allow"
`toolTimeout`	number	30000	Tiempo de espera para ejecución de herramientas (ms)
`cacheResults.enabled`	boolean	true	Habilita caché de resultados
`cacheResults.ttl`	number	300000	Tiempo de vida de la caché (ms)
`cacheResults.maxSize`	number	100	Máximo de resultados en caché
`debug`	boolean	false	Habilita registro de depuración
`autoExecuteTools`	boolean	true	Ejecuta herramientas solicitadas y devuelve resultados al modelo
`maxIterations`	number	5	Máximo de idas y vueltas del modelo en una llamada `chat()`

Ejemplo Completo

const agent = createAgent({
  provider: "openai",
  model: "gpt-4o",
  toolConfig: {
    forceToolUse: true,
    maxRetries: 3,
    onToolNotCalled: "retry",
    toolTimeout: 30000,
    cacheResults: {
      enabled: true,
      ttl: 300000,
      maxSize: 100,
    },
    debug: true,
  },
  tools: [
    {
      name: "get_weather",
      description: "Get current weather for a location",
      parameters: {
        type: "object",
        properties: {
          location: { type: "string" },
        },
        required: ["location"],
      },
      handler: async ({ location }) => {
        // Your weather API logic
        return { location, temp: 72, condition: "Sunny" };
      },
    },
  ],
});

// Tools are executed automatically and their results are sent back to the
// model, so `content` is the final answer — not an empty string with a
// pending tool call.
const response = await agent.chat("What's the weather in NYC?");

console.log(response.content);      // "It's 72°F and sunny in New York."
console.log(response.toolResults);  // [{ name: 'get_weather', result: {...} }]
console.log(response.iterations);   // 2 (one call for the tool, one for the answer)

// Or execute directly with retry and caching
const result = await agent.executeTool("get_weather", {
  location: "New York, NY",
});

Servidores MCP

Crea servidores de Protocolo de Contexto de Modelo para exponer herramientas y recursos.

Servidor MCP Básico

import { createMCPServer } from "mcp-agent-kit";

const server = await createMCPServer({
  name: "my-mcp-server",
  port: 7777,
  logLevel: "info",
});

await server.start(); // Starts on stdio by default

Con Herramientas

const server = await createMCPServer({
  name: "weather-server",
  tools: [
    {
      name: "get_weather",
      description: "Get current weather",
      inputSchema: {
        type: "object",
        properties: {
          location: { type: "string" },
          units: { type: "string", enum: ["celsius", "fahrenheit"] },
        },
        required: ["location"],
      },
      handler: async ({ location, units = "celsius" }) => {
        // Your weather API logic here
        return { location, temp: 22, units, condition: "Sunny" };
      },
    },
  ],
});

Con Recursos

const server = await createMCPServer({
  name: "data-server",
  resources: [
    {
      uri: "config://app-settings",
      name: "Application Settings",
      description: "Current app configuration",
      mimeType: "application/json",
      handler: async () => {
        return JSON.stringify({ version: "1.0.0", env: "production" });
      },
    },
  ],
});

Transporte HTTP Streamable

const server = await createMCPServer({
  name: "http-server",
  port: 8080,
  path: "/mcp", // default
});

await server.start("http"); // Serves MCP at http://localhost:8080/mcp

El transporte websocket se eliminó en v1.2.0. Aceptaba conexiones pero nunca se conectó al servidor MCP, por lo que no respondía a ninguna solicitud mientras se reportaba como saludable. Usa "http" (HTTP Streamable) en su lugar — es el transporte que hablan los clientes MCP actuales.

Orquestador MCP

createMCPServer publica herramientas. connectMCP es la otra mitad: se conecta a servidores MCP, agrega sus herramientas detrás de un espacio de nombres, y las entrega a un agente — sin gateway, sin proxy, sin contenedor.

Conectarse a varios servidores

import { connectMCP, createAgent } from "mcp-agent-kit";

const mcp = await connectMCP({
  servers: {
    // stdio: started as a child process
    files: {
      command: "npx",
      args: ["-y", "@modelcontextprotocol/server-filesystem", "./"],
    },
    // Streamable HTTP: a remote server
    github: {
      url: "https://mcp.example.com/mcp",
      headers: { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` },
    },
  },
});

const agent = createAgent({ provider: "openai" });
agent.use(mcp); // every MCP tool is now callable by the agent

const answer = await agent.chat("Summarise the open issues into notes.md");

await mcp.close();

Las herramientas están espaciadas por servidor, así que dos servidores pueden exponer read sin colisionar: files__read, github__read.

Filtrar la superficie de herramientas

Seis servidores fácilmente suman 60 herramientas, lo que abulta el prompt y degrada las elecciones del modelo. Expón solo lo que la tarea necesita:

const mcp = await connectMCP({
  servers: {
    files: { command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "./"] },
  },
  // Globs match the namespaced name
  allowTools: ["files__read_*", "files__list_*"],
  denyTools: ["*__delete_*"],
});

Los filtros también se pueden establecer por servidor, contra el nombre de herramienta desnudo:

const mcp = await connectMCP({
  servers: {
    files: {
      command: "npx",
      args: ["-y", "@modelcontextprotocol/server-filesystem", "./"],
      denyTools: ["write_file", "move_file"],
    },
  },
});

Un servidor caído no arrastra al agente

Por defecto, un servidor fallido degrada el conjunto de herramientas y el resto sigue funcionando:

const mcp = await connectMCP({
  servers: {
    good: { command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "./"] },
    flaky: { url: "https://might-be-down.example.com/mcp" },
  },
});

console.log(mcp.listServers());
// [{ name: 'good',  state: 'connected', tools: 12, toolsAvailable: 12 },
//  { name: 'flaky', state: 'failed', error: 'fetch failed', tools: 0 }]

Pasa strict: true para fallar toda la conexión en su lugar.

Observabilidad

console.log(mcp.getStats());
// { servers: 2, connected: 1, failed: 1, tools: 12,
//   calls: 4, failedCalls: 0, avgDurationMs: 37 }

console.log(mcp.getCallLog());
// [{ server: 'good', tool: 'read_file', durationMs: 12, ok: true }, ...]

Opciones del Orquestador

Opción	Tipo	Predeterminado	Descripción
`servers`	object	—	Servidores a conectar, claveados por espacio de nombres
`allowTools`	string[]	—	Lista de permitidos de nombres espaciados (globos permitidos)
`denyTools`	string[]	—	Lista de denegados de nombres espaciados (globos permitidos)
`connectTimeout`	number	30000	Tiempo de espera para que un servidor se conecte (ms)
`toolTimeout`	number	60000	Tiempo que una llamada de herramienta puede tomar (ms)
`namespaceSeparator`	string	`__`	Separador entre nombre de servidor y nombre de herramienta
`strict`	boolean	false	Falla toda la conexión cuando cualquier servidor falla
`autoReconnect`	boolean	true	Reconecta y reintenta una vez cuando una conexión se cae

Métodos: getTools(), getServerTools(name), getRawTools(name), listResources(name), callTool(name, params), listServers(), getStats(), getCallLog(), getServerLogs(name), reconnect(name), close().

CLI: inspeccionar un servidor MCP

inspect se conecta a cualquier servidor MCP, lista lo que publica, valida sus esquemas de herramientas y mide los tiempos de ida y vuelta. No necesita configuración ni código — apúntalo a un servidor y lee el informe.

npx mcp-agent-kit inspect npx -y @modelcontextprotocol/server-filesystem ./

Target     npx -y @modelcontextprotocol/server-filesystem ./
Transport  stdio

✓ connected in 2453ms
✓ 14 tool(s), 0 resource(s) listed in 2ms

TOOLS
  ⚠ read_file                  { path: string, tail?: number, head?: number }
  ✓ read_multiple_files        { paths: array }
  ⚠ write_file                 { path: string, content: string }
  ...

ISSUES
  ⚠ read_file: property "path" has no description

Summary  14 tool(s) · 0 resource(s) · 0 errors · 18 warning(s)

Qué valida

Los errores son cosas que un cliente real rechazará; las advertencias son cosas que hacen que un modelo elija peor:

Nivel	Verificación
Error	Nombre de herramienta fuera de `[a-zA-Z0-9_-]{1,64}` — OpenAI y Anthropic lo rechazan
Error	`required` lista una clave que `properties` no declara
Error	Falta `inputSchema`, o `type` distinto de `object`
Error	Nombres de herramienta duplicados
Advertencia	Herramienta o propiedad sin descripción
Advertencia	Propiedad sin tipo declarado

Llamar a una herramienta

npx mcp-agent-kit inspect --call read_file --args '{"path":"README.md"}' \
  npx -y @modelcontextprotocol/server-filesystem ./

Servidores remotos

npx mcp-agent-kit inspect https://mcp.example.com/mcp -H "Authorization: Bearer $TOKEN"

En CI

--json da salida legible por máquina, y el código de salida es significativo: 0 limpio, 1 errores de esquema, 2 no se pudo conectar.

npx mcp-agent-kit inspect --json node ./my-server.js | jq '.issues'

Opciones

Opción	Descripción
`--json`	Salida legible por máquina
`--quiet`, `-q`	Solo resumen y problemas
`--timeout <ms>`	Tiempo de espera de conexión y llamada (predeterminado 30000)
`--header`, `-H`	Cabecera HTTP, repetible (`"Name: value"`)
`--env`, `-e`	Variable de entorno para un servidor stdio, repetible
`--call <tool>`	Llamar a una herramienta después de inspeccionar
`--args <json>`	Argumentos para `--call`

Las opciones van antes del objetivo; todo después del objetivo es la propia línea de comandos del servidor.

Enrutador LLM

Enruta solicitudes a diferentes LLMs basándose en reglas inteligentes.

Enrutador Básico

import { createLLMRouter } from "mcp-agent-kit";

const router = createLLMRouter({
  rules: [
    {
      when: (input) => input.length < 200,
      use: { provider: "openai", model: "gpt-4o" },
    },
    {
      when: (input) => input.includes("code"),
      use: { provider: "anthropic", model: "claude-opus-5" },
    },
    {
      default: true,
      use: { provider: "openai", model: "gpt-4o" },
    },
  ],
});

const response = await router.route("Write a function to sort an array");

Con Respaldo y Reintento

const router = createLLMRouter({
  rules: [...],
  fallback: {
    provider: 'openai',
    model: 'gpt-4o'
  },
  retryAttempts: 3,
  logLevel: 'debug'
});

Estadísticas del Enrutador

const stats = router.getStats();
console.log(stats);
// { totalRules: 3, totalAgents: 2, hasFallback: true }

const agents = router.listAgents();
console.log(agents);
// ['openai:gpt-4o', 'anthropic:claude-opus-5']

Chatbots

Crea IA conversacional con gestión automática de memoria.

Chatbot Básico

import { createChatbot, createAgent } from "mcp-agent-kit";

const bot = createChatbot({
  agent: createAgent({ provider: "openai" }),
  system: "You are a helpful assistant",
  maxHistory: 10,
});

await bot.chat("Hi, I am learning TypeScript");
await bot.chat("Can you help me with interfaces?");
await bot.chat("Thanks!");

Con Enrutador

const bot = createChatbot({
  router: createLLMRouter({ rules: [...] }),
  maxHistory: 20
});

Gestión de Memoria

// Get conversation history
const history = bot.getHistory();

// Get statistics
const stats = bot.getStats();
console.log(stats);
// {
//   messageCount: 6,
//   userMessages: 3,
//   assistantMessages: 3,
//   oldestMessage: Date,
//   newestMessage: Date
// }

// Reset conversation
bot.reset();

// Update system prompt
bot.setSystemPrompt("You are now a Python expert");

Solicitudes API

Solicitudes HTTP simplificadas con reintento automático y tiempo de espera.

Solicitud Básica

import { api } from "mcp-agent-kit";

const response = await api.get("https://api.example.com/data");
console.log(response.data);

Solicitud POST

const response = await api.post(
  "https://api.example.com/users",
  { name: "John", email: "john@example.com" },
  {
    name: "create-user",
    headers: { "Content-Type": "application/json" },
  }
);

Con Reintento y Tiempo de Espera

const response = await api.request({
  name: "important-request",
  url: "https://api.example.com/data",
  method: "GET",
  timeout: 10000, // 10 seconds
  retries: 5, // 5 attempts
  query: { page: 1, limit: 10 },
});

Todos los Métodos HTTP

await api.get(url, config);
await api.post(url, body, config);
await api.put(url, body, config);
await api.patch(url, body, config);
await api.delete(url, config);

Configuración

Variables de Entorno

Toda la configuración es opcional. Establece estas variables de entorno o pásalas en código:

# MCP Server
MCP_SERVER_NAME=my-server
MCP_PORT=7777

# Logging
LOG_LEVEL=info  # debug | info | warn | error

# LLM API Keys
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GEMINI_API_KEY=...
OLLAMA_HOST=http://localhost:11434

Usando Archivo .env

# .env
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
LOG_LEVEL=debug

El paquete carga automáticamente archivos .env usando dotenv.

Ejemplos

Revisa el directorio /examples para ejemplos completos y funcionales:

basic-agent.ts - Uso simple de agente
smart-tool-calling.ts - Llamada inteligente de herramientas con reintento y caché
mcp-server.ts - Servidor MCP con herramientas y recursos
mcp-server-http.ts - Servidor MCP sobre HTTP Streamable
mcp-orchestrator.ts - Conecta varios servidores MCP y entrégalos a un agente
llm-router.ts - Enrutamiento inteligente entre LLMs
chatbot-basic.ts - Chatbot con memoria de conversación
chatbot-with-router.ts - Chatbot usando enrutador
api-requests.ts - Solicitudes HTTP con reintento

Ejecutando Ejemplos

# Install dependencies
npm install

# Run an example
npx ts-node examples/basic-agent.ts

Referencia de API

API de Agente

`createAgent(config: AgentConfig)`

Crea una nueva instancia de agente de IA.

Parámetros:

provider (requerido): Proveedor de LLM - "openai", "anthropic", "gemini" u "ollama"
model (opcional): Nombre del modelo (predeterminado al del proveedor)
temperature (opcional): Temperatura de muestreo 0-2 (predeterminado: 0.7)
maxTokens (opcional): Máximo de tokens en la respuesta (predeterminado: 2000)
apiKey (opcional): Clave API (se lee del entorno si no se proporciona)
tools (opcional): Matriz de definiciones de herramientas
system (opcional): Prompt de sistema
toolConfig (opcional): Configuración de llamada inteligente de herramientas

Devuelve: Instancia de Agente

Métodos:

chat(message: string | AgentMessage[]): Promise<AgentResponse> - Envía un mensaje y obtén la respuesta final, ejecutando las herramientas que el modelo solicite
executeTool(name: string, params: any): Promise<any> - Ejecuta una herramienta directamente
registerTools(tools: AgentTool[]): Agent - Añade herramientas a un agente en vivo
listTools(): AgentTool[] - Herramientas actualmente visibles para el modelo
cleanup(): void - Libera temporizadores de caché

`AgentResponse`

Objeto de respuesta de agent.chat():

{
  content: string;           // Final response text
  toolCalls?: Array<{        // Tools still pending (empty once the loop finishes)
    id?: string;
    name: string;
    arguments: any;
  }>;
  toolResults?: Array<{      // Tools executed while producing this response
    toolCallId: string;
    name: string;
    result: any;
    isError?: boolean;
  }>;
  iterations?: number;       // Model round-trips taken (1 when no tool ran)
  usage?: {                  // Token usage, summed across every round-trip
    promptTokens: number;
    completionTokens: number;
    totalTokens: number;
  };
}

API de Servidor MCP

`createMCPServer(config: MCPServerConfig)`

Crea una nueva instancia de servidor MCP.

Parámetros:

name (opcional): Nombre del servidor (por defecto: desde env o "mcp-server")
port (opcional): Número de puerto (por defecto: 7777)
logLevel (opcional): Nivel de registro - "debug", "info", "warn", "error"
tools (opcional): Matriz de definiciones de herramientas
resources (opcional): Matriz de definiciones de recursos

Devuelve: Promise<MCPServer> — la función es asíncrona (primero carga el SDK de MCP), por lo que siempre debe await

Métodos:

start(transport?: "stdio" | "websocket"): Promise<void> - Iniciar el servidor

API del Router

`createLLMRouter(config: LLMRouterConfig)`

Crea una nueva instancia de router LLM.

Parámetros:

rules (obligatorio): Matriz de reglas de enrutamiento
fallback (opcional): Configuración del proveedor de respaldo
retryAttempts (opcional): Número de intentos de reintento (por defecto: 3)
logLevel (opcional): Nivel de registro

Devuelve: Instancia del router

Métodos:

route(input: string): Promise<AgentResponse> - Enrutar entrada al LLM apropiado
getStats(): object - Obtener estadísticas del router
listAgents(): string[] - Listar todos los agentes configurados

API del Chatbot

`createChatbot(config: ChatbotConfig)`

Crea una nueva instancia de chatbot con memoria de conversación.

Parámetros:

agent o router (obligatorio): Instancia de agente o router
system (opcional): Prompt del sistema
maxHistory (opcional): Número máximo de mensajes a conservar (por defecto: 10)

Devuelve: Instancia del chatbot

Métodos:

chat(message: string): Promise<string> - Enviar mensaje con contexto, devuelve el texto de respuesta
getHistory(): ChatMessage[] - Obtener historial de conversación
getStats(): object - Obtener estadísticas de conversación
reset(): void - Borrar historial de conversación
setSystemPrompt(prompt: string): void - Actualizar prompt del sistema

Ayudantes de Solicitudes API

`api.request(config: APIRequestConfig)`

Realiza solicitudes HTTP con reintento y tiempo de espera.

Parámetros:

name (opcional): Nombre de la solicitud para registro
url (obligatorio): URL de la solicitud
method (opcional): Método HTTP (por defecto: "GET")
headers (opcional): Cabeceras de la solicitud
query (opcional): Parámetros de consulta
body (opcional): Cuerpo de la solicitud
timeout (opcional): Tiempo de espera en ms (por defecto: 30000)
retries (opcional): Intentos de reintento (por defecto: 3)

Devuelve: Promise<APIResponse>

Métodos de conveniencia:

api.get(url, config?) - Solicitud GET
api.post(url, body, config?) - Solicitud POST
api.put(url, body, config?) - Solicitud PUT
api.patch(url, body, config?) - Solicitud PATCH
api.delete(url, config?) - Solicitud DELETE

Uso Avanzado

Proveedor Personalizado

// Coming soon: Plugin system for custom providers

Middleware

// Coming soon: Middleware support for request/response processing

Respuestas en Streaming

// Coming soon: Streaming support for real-time responses

Contribuciones

¡Las contribuciones son bienvenidas! No dudes en enviar un Pull Request.

Haz un fork del repositorio
Crea tu rama de características (git checkout -b feature/amazing-feature)
Realiza tus cambios (git commit -m 'Add amazing feature')
Empuja a la rama (git push origin feature/amazing-feature)
Abre un Pull Request

Licencia

Agradecimientos

Construido con TypeScript
Utiliza MCP SDK
Impulsado por OpenAI, Anthropic, Google y Ollama

Soporte

Correo electrónico: houessoudominique@gmail.com
Problemas: GitHub Issues
Discusiones: GitHub Discussions

Hecho por desarrolladores, para desarrolladores