mcp-agent-kit

mcp-agent-kit

Orquestre servidores MCP e construa agentes de IA em TypeScript — no seu aplicativo, não na sua infraestrutura

Conecte seu agente a vários servidores MCP em três linhas — sem gateway, sem proxy, sem contêiner:

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 é um pacote TypeScript para trabalhar com MCP dentro do seu aplicativo:

• 🎛️ Orquestrador MCP — conecte-se a muitos servidores MCP, agregue e filtre suas ferramentas
• 🔍 CLI inspect — valide as ferramentas de qualquer servidor MCP sem escrever código
• 🔌 Servidores MCP — publique suas próprias ferramentas via stdio ou Streamable HTTP
• 🤖 Agentes de IA com execução automática de ferramentas em quatro provedores de LLM
• 🧠 Roteadores Inteligentes para roteamento multi-LLM
• 💬 Chatbots com memória de conversa
• 🌐 Auxiliares de API com repetição e tempo limite

Recursos

• Em processo: um npm install, não outro serviço para implantar
• Loop de ferramentas incluído: as ferramentas são executadas e seus resultados realimentados ao modelo
• Filtragem de ferramentas: globs de permitir/negar evitam que 60 ferramentas inchem o prompt
• Isolamento de falhas: um servidor inativo degrada o conjunto de ferramentas, não o agente
• Multi-Provedor: OpenAI, Anthropic, Gemini, Ollama
• Type-Safe: Suporte completo a TypeScript com autocompletar
• Documentação verificada: todos os exemplos nesta página são compilados no CI

Instalação

npm install mcp-agent-kit

Início Rápido

Crie um Agente de IA (1 linha!)

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

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

Crie um Servidor MCP (1 função!)

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

Crie um Chatbot com Memória

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!

Documentação

Índice

• Agentes de IA
• Servidores MCP
• Orquestrador MCP
• CLI: inspecionar
• Roteador LLM
• Chatbots
• Requisições de API
• Configuração
• Exemplos

---

Agentes de IA

Crie agentes inteligentes que trabalham com múltiplos provedores 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);

Provedores Suportados

Provedor	Modelos	Chave de API Necessária
OpenAI	GPT-4o, GPT-4, série o	✅ Sim
Anthropic	Claude Opus 5, Sonnet 5	✅ Sim
Gemini	Gemini 2.0+	✅ Sim
Ollama	Modelos locais	❌ Não

Com Ferramentas (Chamada de Função)

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?");

Com Prompt de Sistema

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

Chamada Inteligente de Ferramentas

A Chamada Inteligente de Ferramentas adiciona confiabilidade e desempenho à execução de ferramentas com repetição automática, tempo limite e cache.

Configuração 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: [...],
});

Com Cache

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

Execução Direta de Ferramentas

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

Opções de Configuração

Opção	Tipo	Padrão	Descrição
forceToolUse	boolean	false	Força o modelo a usar ferramentas quando disponíveis
maxRetries	number	3	Tentativas máximas de repetição em falha de ferramenta
onToolNotCalled	string	"retry"	Ação quando a ferramenta não é chamada: "retry", "error", "warn", "allow"
toolTimeout	number	30000	Tempo limite para execução de ferramenta (ms)
cacheResults.enabled	boolean	true	Habilita cache de resultados
cacheResults.ttl	number	300000	Tempo de vida do cache (ms)
cacheResults.maxSize	number	100	Máximo de resultados em cache
debug	boolean	false	Habilita registro de depuração
autoExecuteTools	boolean	true	Executa ferramentas solicitadas e realimenta resultados ao modelo
maxIterations	number	5	Máximo de idas e voltas do modelo em uma chamada chat()

Exemplo 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

Crie servidores do Model Context Protocol para expor ferramentas e 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

Com Ferramentas

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

Com 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 Transmissível (Streamable HTTP)

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

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

O transporte websocket foi removido na v1.2.0. Ele aceitava conexões, mas nunca foi conectado ao servidor MCP, então não respondia a nenhuma requisição enquanto se reportava como saudável. Use "http" (Streamable HTTP) — é o transporte que os clientes MCP atuais falam.

---

Orquestrador MCP

createMCPServer publica ferramentas. connectMCP é a outra metade: conecta-se a servidores MCP, agrega suas ferramentas sob um único namespace e as entrega a um agente — sem gateway, sem proxy, sem contêiner.

Conecte-se a vários 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();

As ferramentas são namespaced por servidor, então dois servidores podem ambos expor read sem colidir: files__read, github__read.

Filtre a superfície de ferramentas

Seis servidores facilmente somam 60 ferramentas, o que incha o prompt e degrada as escolhas do modelo. Exponha apenas o que a tarefa precisa:

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_*"],
});

Filtros também podem ser definidos por servidor, contra o nome da ferramenta sem namespace:

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

Um servidor inativo não derruba o agente junto

Por padrão, um servidor com falha degrada o conjunto de ferramentas e o restante continua 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 }]

Passe strict: true para falhar toda a conexão.

Observabilidade

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 }, ...]

Opções do Orquestrador

Opção	Tipo	Padrão	Descrição
servers	object	—	Servidores para conectar, chaveados por namespace
allowTools	string[]	—	Lista de permissão de nomes com namespace (globs permitidos)
denyTools	string[]	—	Lista de negação de nomes com namespace (globs permitidos)
connectTimeout	number	30000	Tempo para esperar um servidor conectar (ms)
toolTimeout	number	60000	Tempo que uma única chamada de ferramenta pode levar (ms)
namespaceSeparator	string	__	Separador entre nome do servidor e nome da ferramenta
strict	boolean	false	Falha toda a conexão quando qualquer servidor falha
autoReconnect	boolean	true	Reconecta e tenta novamente uma vez quando a conexão cai

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

---

CLI: inspecionar um servidor MCP

inspect conecta-se a qualquer servidor MCP, lista o que ele publica, valida seus esquemas de ferramentas e cronometra as idas e voltas. Não precisa de configuração nem código — aponte para um servidor e leia o relatório.

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)

O que ele valida

Erros são coisas que um cliente real rejeitará; avisos são coisas que fazem um modelo escolher pior:

Nível	Verificação
Erro	Nome da ferramenta fora de [a-zA-Z0-9_-]{1,64} — OpenAI e Anthropic rejeitam
Erro	required lista uma chave que properties não declara
Erro	inputSchema ausente, ou type diferente de object
Erro	Nomes de ferramentas duplicados
Aviso	Ferramenta ou propriedade sem descrição
Aviso	Propriedade sem tipo declarado

Chamar uma ferramenta

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"

No CI

--json fornece saída legível por máquina, e o código de saída é significativo: 0 limpo, 1 erros de esquema, 2 não foi possível conectar.

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

Opções

Opção	Descrição
--json	Saída legível por máquina
--quiet, -q	Apenas resumo e problemas
--timeout <ms>	Tempo limite de conexão e chamada (padrão 30000)
--header, -H	Cabeçalho HTTP, repetível ("Name: value")
--env, -e	Variável de ambiente para servidor stdio, repetível
--call <tool>	Chamar uma ferramenta após inspecionar
--args <json>	Argumentos para --call

Opções vão antes do alvo; tudo após o alvo é a própria linha de comando do servidor.

---

Roteador LLM

Roteie requisições para diferentes LLMs com base em regras inteligentes.

Roteador 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");

Com Fallback e Repetição

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

Estatísticas do Roteador

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

Crie IA conversacional com gerenciamento automático de memória.

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!");

Com Roteador

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

Gerenciamento de Memória

// 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");

---

Requisições de API

Requisições HTTP simplificadas com repetição automática e tempo limite.

Requisição Básica

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

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

Requisição 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" },
  }
);

Com Repetição e Tempo Limite

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 os 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);

---

Configuração

Variáveis de Ambiente

Toda a configuração é opcional. Defina estas variáveis de ambiente ou passe-as no 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 Arquivo .env

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

O pacote carrega automaticamente arquivos .env usando dotenv.

---

Exemplos

Confira o diretório /examples para exemplos completos e funcionais:

• basic-agent.ts - Uso simples de agente
• smart-tool-calling.ts - Chamada inteligente de ferramentas com repetição e cache
• mcp-server.ts - Servidor MCP com ferramentas e recursos
• mcp-server-http.ts - Servidor MCP via Streamable HTTP
• mcp-orchestrator.ts - Conecte-se a vários servidores MCP e entregue-os a um agente
• llm-router.ts - Roteamento inteligente entre LLMs
• chatbot-basic.ts - Chatbot com memória de conversa
• chatbot-with-router.ts - Chatbot usando roteador
• api-requests.ts - Requisições HTTP com repetição

Executando Exemplos

# Install dependencies
npm install

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

---

Referência da API

API do Agente

createAgent(config: AgentConfig)

Cria uma nova instância de agente de IA.

Parâmetros:

• provider (obrigatório): Provedor de LLM - "openai", "anthropic", "gemini" ou "ollama"
• model (opcional): Nome do modelo (padrão é o padrão do provedor)
• temperature (opcional): Temperatura de amostragem 0-2 (padrão: 0.7)
• maxTokens (opcional): Máximo de tokens na resposta (padrão: 2000)
• apiKey (opcional): Chave de API (lê do ambiente se não for fornecida)
• tools (opcional): Matriz de definições de ferramentas
• system (opcional): Prompt de sistema
• toolConfig (opcional): Configuração de chamada inteligente de ferramentas

Retorna: Instância de agente

Métodos:

• chat(message: string | AgentMessage[]): Promise<AgentResponse> - Envie uma mensagem e obtenha a resposta final, executando quaisquer ferramentas que o modelo solicitar
• executeTool(name: string, params: any): Promise<any> - Execute uma ferramenta diretamente
• registerTools(tools: AgentTool[]): Agent - Adicione ferramentas a um agente ativo
• listTools(): AgentTool[] - Ferramentas atualmente visíveis ao modelo
• cleanup(): void - Libere temporizadores de cache

AgentResponse

Objeto de resposta 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 do Servidor MCP

createMCPServer(config: MCPServerConfig)

Cria uma nova instância de servidor MCP.

Parâmetros:

• name (opcional): Nome do servidor (padrão: da env ou "mcp-server")
• port (opcional): Número da porta (padrão: 7777)
• logLevel (opcional): Nível de log - "debug", "info", "warn", "error"
• tools (opcional): Matriz de definições de ferramentas
• resources (opcional): Matriz de definições de recursos

Retorna: Promise<MCPServer> — a função é assíncrona (ela carrega o MCP SDK primeiro), então sempre await ela

Métodos:

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

API do Roteador

createLLMRouter(config: LLMRouterConfig)

Cria uma nova instância de roteador de LLM.

Parâmetros:

• rules (obrigatório): Matriz de regras de roteamento
• fallback (opcional): Configuração do provedor de fallback
• retryAttempts (opcional): Número de tentativas de repetição (padrão: 3)
• logLevel (opcional): Nível de log

Retorna: Instância do roteador

Métodos:

• route(input: string): Promise<AgentResponse> - Roteia a entrada para o LLM apropriado
• getStats(): object - Obtém estatísticas do roteador
• listAgents(): string[] - Lista todos os agentes configurados

API do Chatbot

createChatbot(config: ChatbotConfig)

Cria uma nova instância de chatbot com memória de conversa.

Parâmetros:

• agent ou router (obrigatório): Instância de agente ou roteador
• system (opcional): Prompt do sistema
• maxHistory (opcional): Número máximo de mensagens a manter (padrão: 10)

Retorna: Instância do chatbot

Métodos:

• chat(message: string): Promise<string> - Envia mensagem com contexto, retorna o texto da resposta
• getHistory(): ChatMessage[] - Obtém o histórico da conversa
• getStats(): object - Obtém estatísticas da conversa
• reset(): void - Limpa o histórico da conversa
• setSystemPrompt(prompt: string): void - Atualiza o prompt do sistema

Auxiliares de Requisição de API

api.request(config: APIRequestConfig)

Faz requisição HTTP com repetição e tempo limite.

Parâmetros:

• name (opcional): Nome da requisição para registro
• url (obrigatório): URL da requisição
• method (opcional): Método HTTP (padrão: "GET")
• headers (opcional): Cabeçalhos da requisição
• query (opcional): Parâmetros de consulta
• body (opcional): Corpo da requisição
• timeout (opcional): Tempo limite em ms (padrão: 30000)
• retries (opcional): Tentativas de repetição (padrão: 3)

Retorna: Promise<APIResponse>

Métodos de Conveniência:

• api.get(url, config?) - Requisição GET
• api.post(url, body, config?) - Requisição POST
• api.put(url, body, config?) - Requisição PUT
• api.patch(url, body, config?) - Requisição PATCH
• api.delete(url, config?) - Requisição DELETE

---

Uso Avançado

Provedor Personalizado

// Coming soon: Plugin system for custom providers

Middleware

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

Respostas em Streaming

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

---

Contribuindo

Contribuições são bem-vindas! Sinta-se à vontade para enviar um Pull Request.

1. Faça um fork do repositório
2. Crie sua branch de recurso (git checkout -b feature/amazing-feature)
3. Faça commit das suas alterações (git commit -m 'Add amazing feature')
4. Envie para a branch (git push origin feature/amazing-feature)
5. Abra um Pull Request

---

Licença

MIT © Dominique Kossi

---

Agradecimentos

• Construído com TypeScript
• Usa MCP SDK
• Alimentado por OpenAI, Anthropic, Google e Ollama

---

Suporte

• E-mail: houessoudominique@gmail.com
• Problemas: GitHub Issues
• Discussões: GitHub Discussions

---

Feito por desenvolvedores, para desenvolvedores