Tu primer servidor MCP

import logging, os, pathlib, sys
from typing import Annotated
from pydantic import Field
from mcp.server.mcpserver import MCPServer
from mcp.server.mcpserver.exceptions import ToolError

logging.basicConfig(stream=sys.stderr, level=logging.INFO)   # nunca a stdout con stdio
log = logging.getLogger("notas")

RAIZ = pathlib.Path(os.environ.get("NOTAS_DIR", "./notas")).resolve()
mcp = MCPServer("notas")

def ruta_segura(nombre: str) -> pathlib.Path:
    p = (RAIZ / nombre).resolve()
    if not p.is_relative_to(RAIZ) or p.suffix != ".md":
        raise ToolError(f"Nombre no válido: {nombre!r}. Usa un nombre devuelto por buscar_notas.")
    if not p.exists():
        raise ToolError(f"No existe la nota {nombre!r}. Usa buscar_notas para ver las disponibles.")
    return p

@mcp.tool()
def buscar_notas(
    consulta: Annotated[str, Field(description="Palabra o frase a buscar, sin comillas.")],
    limite: Annotated[int, Field(description="Máximo de resultados (1-20).", ge=1, le=20)] = 5,
) -> str:
    """Busca texto en las notas de la carpeta y devuelve el nombre de cada nota con un
    extracto alrededor de la coincidencia. Úsala antes de leer_nota para saber qué existe.
    No distingue mayúsculas. Si no hay resultados, prueba con sinónimos o una sola palabra."""
    q = consulta.lower()
    hits = []
    for p in sorted(RAIZ.rglob("*.md")):
        texto = p.read_text(encoding="utf-8", errors="replace")
        i = texto.lower().find(q)
        if i >= 0:
            extracto = texto[max(0, i - 80): i + 120].replace("\n", " ")
            hits.append(f"{p.relative_to(RAIZ)}: …{extracto}…")
        if len(hits) >= limite:
            break
    log.info("buscar_notas %r -> %d", consulta, len(hits))
    return "\n".join(hits) or "Sin resultados. Prueba con otra palabra clave."

@mcp.tool()
def leer_nota(
    nombre: Annotated[str, Field(description="Nombre relativo tal como lo devuelve buscar_notas, p. ej. 'reuniones/lunes.md'.")],
) -> str:
    """Devuelve el contenido completo de una nota en Markdown. Solo lectura."""
    return ruta_segura(nombre).read_text(encoding="utf-8", errors="replace")

@mcp.resource("notas://{+nombre}")   # {+nombre} admite «/», para notas en subcarpetas
def nota(nombre: str) -> str:
    """Una nota como recurso, para que el host la adjunte al contexto."""
    return ruta_segura(nombre).read_text(encoding="utf-8", errors="replace")

@mcp.prompt()
def resumir_nota(nombre: str) -> str:
    """Resume una nota con decisiones, tareas y responsables."""
    return (f"Lee la nota {nombre} con la herramienta leer_nota y resúmela en tres apartados: "
            "decisiones, tareas (con responsable si aparece) y preguntas abiertas.")

if __name__ == "__main__":
    mcp.run()          # stdio por defecto

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { readdir, readFile } from "node:fs/promises";
import path from "node:path";

const RAIZ = path.resolve(process.env.NOTAS_DIR ?? "./notas");
const server = new McpServer({ name: "notas", version: "0.1.0" });

function rutaSegura(nombre: string): string {
  const p = path.resolve(RAIZ, nombre);
  if (!p.startsWith(RAIZ + path.sep) || !p.endsWith(".md")) {
    throw new Error(`Nombre no válido: ${nombre}. Usa un nombre devuelto por buscar_notas.`);
  }
  return p;
}

server.registerTool(
  "buscar_notas",
  {
    description:
      "Busca texto en las notas y devuelve nombre y extracto de cada coincidencia. " +
      "Úsala antes de leer_nota. Si no hay resultados, prueba con sinónimos.",
    inputSchema: {
      consulta: z.string().describe("Palabra o frase a buscar, sin comillas."),
      limite: z.number().int().min(1).max(20).default(5).describe("Máximo de resultados."),
    },
  },
  async ({ consulta, limite }) => {
    const q = consulta.toLowerCase();
    const hits: string[] = [];
    const nombres = (await readdir(RAIZ, { recursive: true })).filter((n) => n.endsWith(".md"));
    for (const n of nombres.sort()) {
      const texto = await readFile(path.join(RAIZ, n), "utf8");
      const i = texto.toLowerCase().indexOf(q);
      if (i >= 0) hits.push(`${n}: …${texto.slice(Math.max(0, i - 80), i + 120).replace(/\n/g, " ")}…`);
      if (hits.length >= limite) break;
    }
    return { content: [{ type: "text", text: hits.join("\n") || "Sin resultados. Prueba con otra palabra clave." }] };
  },
);

server.registerTool(
  "leer_nota",
  {
    description: "Devuelve el contenido completo de una nota en Markdown. Solo lectura.",
    inputSchema: { nombre: z.string().describe("Nombre relativo tal como lo devuelve buscar_notas.") },
  },
  async ({ nombre }) => {
    try {
      return { content: [{ type: "text", text: await readFile(rutaSegura(nombre), "utf8") }] };
    } catch (e) {
      return { content: [{ type: "text", text: String(e) }], isError: true };
    }
  },
);

await server.connect(new StdioServerTransport());   // proyecto ESM ("type": "module")