// Para OpenAI: un formato
const tools = [{
  type: "function",
  function: {
    name: "buscar_usuario",
    parameters: { type: "object", properties: { email: { type: "string" } } }
  }
}]
 
// Para Anthropic: otro formato
const tools = [{
  name: "buscar_usuario",
  input_schema: { type: "object", properties: { email: { type: "string" } } }
}]
 
// Para Google Gemini: otro mas
const tools = [{
  functionDeclarations: [{
    name: "buscar_usuario",
    parameters: { type: "object", properties: { email: { type: "string" } } }
  }]
}]

Host (aplicacion de IA)
  |
  +-- Client (maneja la conexion)
        |
        +-- Server (expone capacidades)
              |
              +-- Tools (funciones que la IA puede ejecutar)
              +-- Resources (datos que la IA puede leer)
              +-- Prompts (plantillas reutilizables)

// Ejemplo conceptual de un Tool
{
  name: "buscar_usuario",
  description: "Busca un usuario en la base de datos por email",
  inputSchema: {
    type: "object",
    properties: {
      email: { type: "string", description: "Email del usuario" }
    },
    required: ["email"]
  }
}

// Ejemplo conceptual de un Resource
{
  uri: "db://usuarios/lista",
  name: "Lista de usuarios",
  description: "Todos los usuarios registrados en el sistema",
  mimeType: "application/json"
}

// Ejemplo conceptual de un Prompt
{
  name: "revisar_codigo",
  description: "Analiza codigo y sugiere mejoras",
  arguments: [
    { name: "lenguaje", description: "Lenguaje de programacion", required: true },
    { name: "codigo", description: "Codigo a revisar", required: true }
  ]
}

// tsconfig.json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src/**/*"]
}

// src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
 
// Base de datos simulada
const usuarios = [
  { id: 1, nombre: "Ana Garcia", email: "ana@mail.com", rol: "admin" },
  { id: 2, nombre: "Carlos Lopez", email: "carlos@mail.com", rol: "editor" },
  { id: 3, nombre: "Maria Torres", email: "maria@mail.com", rol: "usuario" },
  { id: 4, nombre: "Pedro Ruiz", email: "pedro@mail.com", rol: "editor" },
];
 
// Crear instancia del servidor
const server = new McpServer({
  name: "mi-servidor-usuarios",
  version: "1.0.0",
});
 
// Tool: buscar usuario por email
server.tool(
  "buscar_usuario",
  "Busca un usuario en la base de datos por su direccion de email",
  { email: z.string().email().describe("Email del usuario a buscar") },
  async ({ email }) => {
    const usuario = usuarios.find(
      (u) => u.email.toLowerCase() === email.toLowerCase()
    );
 
    if (!usuario) {
      return {
        content: [
          {
            type: "text",
            text: `No se encontro un usuario con el email: ${email}`,
          },
        ],
      };
    }
 
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(usuario, null, 2),
        },
      ],
    };
  }
);
 
// Tool: buscar usuarios por rol
server.tool(
  "buscar_por_rol",
  "Busca todos los usuarios que tengan un rol especifico",
  {
    rol: z
      .enum(["admin", "editor", "usuario"])
      .describe("Rol a filtrar: admin, editor o usuario"),
  },
  async ({ rol }) => {
    const resultado = usuarios.filter((u) => u.rol === rol);
 
    return {
      content: [
        {
          type: "text",
          text:
            resultado.length > 0
              ? JSON.stringify(resultado, null, 2)
              : `No hay usuarios con el rol: ${rol}`,
        },
      ],
    };
  }
);
 
// Resource: lista completa de usuarios
server.resource("usuarios://lista", "Lista completa de usuarios registrados", async (uri) => ({
  contents: [
    {
      uri: uri.href,
      mimeType: "application/json",
      text: JSON.stringify(usuarios, null, 2),
    },
  ],
}));
 
// Iniciar el servidor con transporte stdio
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Servidor MCP de usuarios iniciado");
}
 
main().catch(console.error);

{
  "scripts": {
    "start": "tsx src/index.ts"
  }
}

{
  "mcpServers": {
    "mi-servidor-usuarios": {
      "command": "npx",
      "args": ["tsx", "/ruta/absoluta/a/mi-servidor-mcp/src/index.ts"]
    }
  }
}

// lib/mcp-client.ts
import { experimental_createMCPClient as createMCPClient } from "ai";
 
// Crear cliente MCP que se conecta a tu servidor
export async function crearClienteMCP() {
  const client = await createMCPClient({
    transport: {
      type: "sse",
      url: "http://localhost:3001/mcp",
    },
  });
 
  return client;
}

// app/api/chat/route.ts
import { generateText } from "ai";
import { anthropic } from "@ai-sdk/anthropic";
import { crearClienteMCP } from "@/lib/mcp-client";
 
export async function POST(req: Request) {
  const { messages } = await req.json();
 
  // Conectar al servidor MCP
  const mcpClient = await crearClienteMCP();
 
  // Obtener las herramientas del servidor MCP
  const toolsMCP = await mcpClient.tools();
 
  // Usar las herramientas en la generacion de texto
  const resultado = await generateText({
    model: anthropic("claude-sonnet-4-20250514"),
    messages,
    tools: toolsMCP,
    maxSteps: 5,
  });
 
  // Cerrar la conexion al terminar
  await mcpClient.close();
 
  return new Response(JSON.stringify(resultado), {
    headers: { "Content-Type": "application/json" },
  });
}

// Servidor con transporte stdio
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
const transport = new StdioServerTransport();
await server.connect(transport);

// Servidor con transporte SSE
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import express from "express";
 
const app = express();
 
// Mapa para rastrear las conexiones activas
const transports = new Map<string, SSEServerTransport>();
 
// Endpoint SSE para la conexion persistente
app.get("/mcp", (req, res) => {
  const transport = new SSEServerTransport("/mcp/message", res);
  const sessionId = transport.sessionId;
  transports.set(sessionId, transport);
 
  // Conectar el servidor MCP al transporte
  server.connect(transport);
 
  // Limpiar al cerrar la conexion
  req.on("close", () => {
    transports.delete(sessionId);
  });
});
 
// Endpoint para recibir mensajes del cliente
app.post("/mcp/message", (req, res) => {
  const sessionId = req.query.sessionId as string;
  const transport = transports.get(sessionId);
 
  if (transport) {
    transport.handlePostMessage(req, res);
  } else {
    res.status(404).json({ error: "Sesion no encontrada" });
  }
});
 
app.listen(3001, () => {
  console.log("Servidor MCP escuchando en puerto 3001");
});

// Tool que consulta una base de datos real
server.tool(
  "ejecutar_consulta",
  "Ejecuta una consulta SQL de solo lectura contra la base de datos",
  {
    consulta: z.string().describe("Consulta SQL SELECT a ejecutar"),
  },
  async ({ consulta }) => {
    // Validar que sea solo SELECT (nunca permitir INSERT/UPDATE/DELETE)
    const consultaLimpia = consulta.trim().toUpperCase();
    if (!consultaLimpia.startsWith("SELECT")) {
      return {
        content: [
          {
            type: "text",
            text: "Solo se permiten consultas SELECT por seguridad",
          },
        ],
      };
    }
 
    try {
      const resultado = await db.query(consulta);
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify(resultado.rows, null, 2),
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `Error en la consulta: ${(error as Error).message}`,
          },
        ],
      };
    }
  }
);

// Tool que consume una API REST
server.tool(
  "obtener_clima",
  "Obtiene el clima actual de una ciudad",
  {
    ciudad: z.string().describe("Nombre de la ciudad"),
    pais: z.string().optional().describe("Codigo de pais ISO (ej: MX, CO, AR)"),
  },
  async ({ ciudad, pais }) => {
    const query = pais ? `${ciudad},${pais}` : ciudad;
    const url = `https://api.weatherapi.com/v1/current.json?key=${process.env.WEATHER_API_KEY}&q=${encodeURIComponent(query)}&lang=es`;
 
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`API respondio con status ${response.status}`);
      }
 
      const data = await response.json();
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify(
              {
                ubicacion: data.location.name,
                temperatura: `${data.current.temp_c} grados C`,
                condicion: data.current.condition.text,
                humedad: `${data.current.humidity}%`,
              },
              null,
              2
            ),
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `Error al obtener el clima: ${(error as Error).message}`,
          },
        ],
      };
    }
  }
);

import { readdir, readFile, stat } from "fs/promises";
import { join, resolve } from "path";
 
// Directorio raiz permitido (nunca dar acceso a todo el sistema)
const DIRECTORIO_BASE = resolve("./proyecto");
 
// Tool para listar archivos de un directorio
server.tool(
  "listar_archivos",
  "Lista los archivos y carpetas en un directorio del proyecto",
  {
    ruta: z
      .string()
      .default(".")
      .describe("Ruta relativa dentro del proyecto"),
  },
  async ({ ruta }) => {
    const rutaCompleta = resolve(join(DIRECTORIO_BASE, ruta));
 
    // Validar que no salga del directorio base
    if (!rutaCompleta.startsWith(DIRECTORIO_BASE)) {
      return {
        content: [
          { type: "text", text: "Acceso denegado: ruta fuera del proyecto" },
        ],
      };
    }
 
    try {
      const archivos = await readdir(rutaCompleta, { withFileTypes: true });
      const lista = archivos.map((f) => ({
        nombre: f.name,
        tipo: f.isDirectory() ? "directorio" : "archivo",
      }));
 
      return {
        content: [{ type: "text", text: JSON.stringify(lista, null, 2) }],
      };
    } catch (error) {
      return {
        content: [
          { type: "text", text: `Error: ${(error as Error).message}` },
        ],
      };
    }
  }
);
 
// Tool para leer el contenido de un archivo
server.tool(
  "leer_archivo",
  "Lee el contenido de un archivo del proyecto",
  {
    ruta: z.string().describe("Ruta relativa del archivo dentro del proyecto"),
  },
  async ({ ruta }) => {
    const rutaCompleta = resolve(join(DIRECTORIO_BASE, ruta));
 
    if (!rutaCompleta.startsWith(DIRECTORIO_BASE)) {
      return {
        content: [
          { type: "text", text: "Acceso denegado: ruta fuera del proyecto" },
        ],
      };
    }
 
    try {
      const info = await stat(rutaCompleta);
      // Limitar tamano de archivos que se pueden leer
      if (info.size > 100_000) {
        return {
          content: [
            {
              type: "text",
              text: "El archivo supera el limite de 100KB",
            },
          ],
        };
      }
 
      const contenido = await readFile(rutaCompleta, "utf-8");
      return {
        content: [{ type: "text", text: contenido }],
      };
    } catch (error) {
      return {
        content: [
          { type: "text", text: `Error: ${(error as Error).message}` },
        ],
      };
    }
  }
);

// lib/crear-tool.ts
import { z, ZodObject, ZodRawShape } from "zod";
 
// Helper para crear Tools con tipado completo
export function definirTool<T extends ZodRawShape>(config: {
  nombre: string;
  descripcion: string;
  schema: T;
  handler: (params: z.infer<ZodObject<T>>) => Promise<string>;
}) {
  return config;
}
 
// Uso
const buscarUsuario = definirTool({
  nombre: "buscar_usuario",
  descripcion: "Busca un usuario por email",
  schema: {
    email: z.string().email(),
  },
  handler: async ({ email }) => {
    const usuario = await db.query("SELECT * FROM usuarios WHERE email = $1", [email]);
    return JSON.stringify(usuario);
  },
});