mcp-context-window

Un servidor MCP que le da a un modelo local un búfer de contexto externo: memoria de sesión duradera en la que puede escribir notas y documentos grandes que puede hojear sin cargarlos enteros.

Construido con el MCP TypeScript SDK v2 contra la revisión del protocolo 2026-07-28. Se ejecuta sobre stdio (LM Studio, Claude Desktop, cualquier cosa que lance un proceso local) o Streamable HTTP.

Léase primero: qué puede y qué no puede hacer un servidor MCP

Ningún servidor MCP puede ver ni modificar su ventana de contexto. MCP es estrictamente petición/respuesta: el host llama a una herramienta, la herramienta responde. El servidor nunca ve la conversación, no puede interceptar mensajes antes de que lleguen al modelo y no puede recortar nada. LM Studio hace su propio truncamiento internamente y no consulta a ningún servidor al respecto.

Así que esto no es una ventana deslizante automática, y cualquier cosa que se anuncie como tal le está engañando. Lo que sí es: un almacén contra el que el modelo pagina deliberadamente, manteniendo la mayor parte del material fuera de la ventana y recuperando solo lo que necesita. Eso es genuinamente potente con un modelo local de 8k tokens, pero funciona porque el modelo lo llama, no porque intercepte nada.

La consecuencia práctica: el modelo tiene que cooperar. Las descripciones de las herramientas aquí están escritas para ser prescriptivas, y context_guide devuelve el flujo de trabajo previsto. Si su modelo las ignora, dígalo en su mensaje de sistema.

Una nota relacionada: el Muestreo de MCP —el mecanismo que permite a un servidor pedir al LLM del cliente que genere texto— fue desaprobado en la especificación de 2026-07-28, con el consejo oficial de "integrarse directamente con las API del proveedor de LLM". Así que este servidor llama él mismo a un endpoint compatible con OpenAI. Eso es también lo que lo mantiene independiente del arnés: el mismo código funciona con LM Studio, Ollama, llama.cpp o vLLM.

Related MCP server: membot

Las dos mitades

Sesiones: memoria de trabajo a lo largo de una tarea larga

Documentos: material demasiado grande para leerlo de una vez

Además de context_guide, que explica el flujo de trabajo al modelo.

Inicio rápido

npm install
npm run build
npm test

node dist/index.js --ingest-root ./sources

O explórelo de forma interactiva:

npx @modelcontextprotocol/inspector node dist/index.js

LM Studio

Edite ~/.lmstudio/mcp.json (en Windows, C:\Users\<usuario>\.lmstudio\mcp.json) a través de Programa → Instalar → Editar mcp.json y, a continuación, recargue LM Studio.

{
  "mcpServers": {
    "context": {
      "command": "node",
      "args": [
        "/absolute/path/to/mcp-context-sliding/dist/index.js",
        "--ingest-root", "/absolute/path/to/your/project",
        "--budget", "4000"
      ]
    }
  }
}

Estas dos rutas deben ser absolutas. El host lanza el servidor como un proceso hijo con un directorio de trabajo impredecible, por lo que una ruta relativa no se resolverá. En la línea de comandos, donde usted controla el directorio de trabajo, las rutas relativas como --ingest-root ./sources son correctas.

En Windows, escriba barras diagonales (C:/Users/usuario/projects) o duplique las barras invertidas, ya que una sola \ es un carácter de escape dentro de una cadena JSON.

Establezca --budget en aproximadamente la mitad de la longitud de contexto de su modelo. Es el objetivo en el que este servidor empaqueta las recuperaciones, no un límite que LM Studio imponga.

--ingest-root es lo que permite a doc_ingest leer archivos. Si lo omite, el servidor solo acepta texto en línea, que es el valor predeterminado seguro, ya que un servidor que abra rutas arbitrarias por orden de un modelo es un lastre.

Docker

docker build -t mcp-context-window:latest .

{
  "mcpServers": {
    "context": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm", "--init",
        "-v", "mcp-context-data:/data",
        "-v", "/absolute/path/to/your/project:/ingest:ro",
        "-e", "CTX_INGEST_ROOTS=/ingest",
        "--add-host", "host.docker.internal:host-gateway",
        "mcp-context-window:latest", "--stdio"
      ]
    }
  }
}

Dos cosas que pican aquí: -i es obligatorio o el apretón de manos JSON-RPC nunca ocurre, y el volumen con nombre es obligatorio o cada reinicio descarta silenciosamente todas las sesiones almacenadas. Desde dentro de un contenedor, localhost es el contenedor, por lo que la URL base del LLM por defecto es host.docker.internal. Docker también requiere que el lado del host de un enlace de montaje -v sea una ruta absoluta.

Cómo transcurre una sesión realmente

context_open        session_id "refactor-auth"
context_append      "Goal: replace session cookies with JWT" (pinned)
context_append      "auth/middleware.ts:42 assumes a cookie is present"
context_append      "Decision: keep cookie support behind a flag for one release"
...
context_status      → 3200/4000 tokens — approaching budget
context_compact     → folds 14 old entries into one 380-token summary
context_recall      "cookie flag decision" → returns the pinned goal + the decision

Y un documento:

doc_ingest      file_path "logs/build-failure.log"  → doc_kx91, 240 chunks
doc_search      "OutOfMemory"                       → 3 chunks, 1400 tokens
doc_window      from 118 to 121                     → the surrounding context

El registro nunca entró en el contexto del modelo. Tres lecturas específicas sí lo hicieron.

Configuración

Notas de diseño

El recuento de tokens está calibrado con su modelo real. No existe un tokenizador universal —Llama, Qwen y GPT dividen de forma diferente— e incluir uno sería grande e incorrecto para lo que sea que haya cargado. En su lugar, el servidor estima de forma económica y luego mide la verdad: envía dos muestras de diferentes longitudes a su endpoint con max_tokens: 1 y toma la pendiente de los usage.prompt_tokens notificados entre ellas. La pendiente anula la sobrecarga fija de la plantilla de chat y produce el coste marginal real por carácter. El resultado se almacena en caché, por lo que solo la primera ejecución no está calibrada, y se ejecuta en segundo plano para que el arranque nunca se bloquee por un modelo que quizás aún no esté cargado.

Las estimaciones tienden deliberadamente a ser altas. Subestimar desborda la ventana y trunca precisamente el contexto que este servidor existe para proteger.

La generación de resúmenes se degrada en lugar de fallar. Si su endpoint es inalcanzable o no hay ningún modelo cargado, se recurre a la generación de resúmenes extractiva —puntuación de oraciones TF-ISF— que es instantánea, determinista y estructuralmente incapaz de alucinar, ya que solo puede seleccionar oraciones que realmente estaban allí. Perder el acceso al contexto almacenado es un resultado peor que un resumen más tosco del mismo. Tras un fallo, el cliente se retira brevemente, por lo que un documento de 200 fragmentos no espera 200 tiempos de espera TCP separados.

El almacenamiento es JSONL de solo añadidura. Un fallo puede corromper como mucho la última línea, que se omite al cargar en lugar de ser fatal. Haga tail al archivo para ver cómo se acumula la memoria. La compactación marca los originales como reemplazados en lugar de eliminarlos, por lo que una compactación que haya descartado algo importante sigue siendo recuperable desde el registro.

La división en fragmentos sigue la estructura del documento, no compensaciones fijas: los encabezados, los párrafos y los bloques de código delimitados permanecen intactos, y cada fragmento lleva la ruta de encabezados bajo la que se encuentra. Solo un bloque genuinamente más grande que un fragmento completo se divide a la fuerza.

La recuperación es BM25 más actualidad, sin modelo de incrustación. Eso no requiere nada cargado, no cuesta VRAM junto a su modelo principal y es determinista, lo que importa cuando el objetivo es la previsibilidad sobre lo que ve el modelo. Los identificadores se indexan enteros y divididos, por lo que getUserName se puede encontrar como "user name".

Límites

• El modelo debe llamar realmente a estas herramientas. Nada es automático.

• La búsqueda por palabras clave no detecta paráfrasis que un modelo de incrustación sí detectaría.

• Los recuentos de tokens son estimaciones hasta que la primera calibración tiene éxito.

• Ningún transporte autentica; HTTP se vincula a loopback por esa razón.

• doc_ingest lee texto UTF-8. No es un extractor de PDF o DOCX.

Licencia

MIT