Universal Context Pipeline

UCP — Universal Context Pipeline

Un servidor MCP local-first que fundamenta los LLMs en tus propios archivos.

UCP indexa carpetas en tu máquina — notas, código, exportaciones de conversaciones — y las expone a cualquier cliente compatible con MCP (Claude Desktop, Cursor, LM Studio y otros runtimes de agentes locales) como una sola herramienta: search_local_context. Recuperación híbrida (BM25 + vector), fragmentación de código consciente de tree-sitter, citas completas, caché de incrustaciones por hash de contenido. Binario único. Sin telemetría. Sin nube.

Combinado con un modelo local en LM Studio (o Ollama a través de ucp-local ask), toda la pila — indexación, incrustaciones, recuperación y el modelo de chat — funciona completamente sin conexión. Funciona en un avión, en una instalación aislada, o en cualquier lugar donde un LLM en la nube no sea una opción.

Demostraciones

Memoria de conversación: haz que cada chat pasado de Claude sea buscable en cada sesión futura.

RAG aislado — Ollama local + índice local, cero tráfico de red.

Inicio rápido: instala, indexa, pregunta, en menos de un minuto.

¿Para quién es esto?

Si eres…	UCP te da…
Un usuario avanzado de Claude / Cursor / LM Studio	Un archivo buscable de cada conversación de IA pasada, invocable desde cualquier sesión futura como la herramienta search_local_context.
Un ingeniero de software	Código + documentos privados + repositorios hermanos + chats pasados de Claude unificados bajo una herramienta MCP — presentados dentro de Cursor o Claude Code junto a sus indexadores nativos.
Un investigador, escritor o académico	Un corpus de PDF + notas al que puedes hacer preguntas fundamentadas, con citas a nivel de línea, sin que nada salga de la máquina.
En un flujo de trabajo regulado por privacidad (legal, médico, defensa, propiedad intelectual sujeta a NDA)	Un único binario de Rust con cero telemetría y cero nube. Combínalo con LM Studio para una pila RAG completamente sin conexión, de extremo a extremo.
Un fundador o consultor independiente	Aislamiento de cliente por carpeta mediante folder_filter — sin riesgo de filtrar el contexto del cliente A en la sesión del cliente B.

Análisis completo de audiencia, comparación competitiva y las dos ventajas en las que UCP está explícitamente construido para ganar: ver POSITIONING.md.

Estado

v0.1, sin interfaz gráfica. Sigue el alcance en ROADMAP.md.

Lo que incluye:

• Búsqueda híbrida: SQLite FTS5 (BM25) ⨉ sqlite-vec (ANN) fusionado mediante fusión de rango recíproco.
• Fragmentación con tree-sitter para Rust, Python, TypeScript/JavaScript. Markdown consciente de encabezados. Respaldo de prosa limitada por oraciones.
• Memoria de conversación: ingiere tu exportación de Claude conversations.json y busca en chats pasados.
• Enmascaramiento de PII activado por defecto — correo electrónico, OpenAI sk-, claves de AWS, PATs de GitHub, JWT.
• Caché de incrustaciones por hash de contenido: reindexar contenido sin cambios hace cero llamadas a Ollama.
• Vigilante del sistema de archivos: edita un archivo, el índice se actualiza en ~500ms.

Lo que no está en v0.1:

• Interfaz de escritorio / bandeja (diferido — estaba en la especificación original, ahora en el nivel 2+ de ROADMAP).
• Inyector de atajos de teclado del sistema operativo e interceptor de proxy HTTP (eliminados de la especificación original).
• Proveedores de incrustaciones de OpenAI / Anthropic (solo Ollama por ahora).
• Formatos de exportación de Cursor y ChatGPT (solo Claude; otros más adelante).

Requisitos previos

UCP necesita tres cosas en tu máquina: Rust (para compilar), Ollama (para incrustar y opcionalmente chatear) y Poppler (para una extracción robusta de texto PDF — recomendado).

macOS

brew install ollama poppler
ollama serve &              # or use the menu-bar app
ollama pull nomic-embed-text
# Optional, for `ucp-local ask`:  ollama pull llama3.2

Linux (Debian/Ubuntu)

sudo apt install poppler-utils
curl -fsSL https://ollama.com/install.sh | sh
ollama pull nomic-embed-text
# Optional, for `ucp-local ask`:  ollama pull llama3.2

Linux (Fedora/RHEL)

sudo dnf install poppler-utils
curl -fsSL https://ollama.com/install.sh | sh
ollama pull nomic-embed-text

Windows

choco install poppler ollama   # or install each manually
ollama pull nomic-embed-text

Rust (estable, edición 2024) solo se necesita para compilar desde el código fuente. Si instalas un binario UCP precompilado, omite la instalación de Rust.

Poppler es opcional pero recomendado. Sin él, UCP solo usa el pdf-extract incluido para PDFs, que tiene dificultades con PDFs cuyas fuentes del cuerpo carecen de un CMap ToUnicode (verás que los encabezados se extraen pero el texto del cuerpo desaparece). Con pdftotext de Poppler en PATH, UCP recurre a él automáticamente.

Instalación

Nota sobre el nombre. El crate se publica como ucp-local en crates.io — el nombre simple ucp ya estaba tomado. El binario en tu PATH también es ucp-local (eso es lo que escribes en la línea de comandos), y la biblioteca se importa como use ucp_local::....

Desde crates.io

cargo install ucp-local
# Puts the `ucp-local` binary on your PATH

Desde el código fuente

git clone <repo-url> ucp-local
cd ucp-local
cargo build --release
# Binary at target/release/ucp-local
cargo install --path .   # optional, to put `ucp-local` on your PATH

Uso

# Index one folder
ucp-local index ~/Documents/notes

# Index multiple folders into the same store
ucp-local index ~/Documents/notes ~/code/my-project ~/research

# Watch a folder and re-index on changes (initial pass runs first)
ucp-local watch ~/code/my-project

# Clear the index — soft (keeps the embedding cache so re-index is fast)
ucp-local clear

# Clear only one folder's chunks
ucp-local clear ~/Documents/notes

# Hard reset — also wipes the embedding cache, forces re-embed on next index
ucp-local clear --hard --yes

# Ingest a Claude conversations.json export
ucp-local ingest-conversations ~/Downloads/claude-export/conversations.json

# Show config + index status
ucp-local status

# Run the MCP server over stdio (this is what MCP clients launch)
ucp-local serve

# Search the index from the terminal (no LLM) — best for debugging "did indexing actually capture this?"
ucp-local search "your query here"
ucp-local search "rate limiting" --folder ~/code/my-project --limit 10

# Ask a question — runs search internally, then a local chat model answers with citations
ucp-local ask "what does the rate limiter do when a token bucket runs out?"
ucp-local ask "summarize my Q3 plan" --model qwen2.5

Conecta un cliente MCP

UCP habla MCP sobre stdio, por lo que cualquier cliente que lance servidores MCP puede usarlo. Mismo comando serve, diferente archivo de configuración por cliente.

Claude Desktop

Añade a ~/Library/Application Support/Claude/claude_desktop_config.json en macOS (%APPDATA%\Claude\claude_desktop_config.json en Windows):

{
  "mcpServers": {
    "ucp-local": {
      "command": "/full/path/to/ucp-local",
      "args": ["serve"]
    }
  }
}

Reinicia Claude Desktop. La herramienta search_local_context estará disponible — pregunta algo fundamentado en tus archivos indexados y los citará en línea.

Cursor

Cursor lee servidores MCP desde ~/.cursor/mcp.json (o por proyecto .cursor/mcp.json):

{
  "mcpServers": {
    "ucp-local": {
      "command": "/full/path/to/ucp-local",
      "args": ["serve"]
    }
  }
}

Recarga Cursor. La barra lateral de chat mostrará search_local_context como herramienta — útil para fundamentar al agente en repos y documentos que el indexador @codebase de Cursor no puede alcanzar (notas privadas, historial de conversaciones, repositorios hermanos).

LM Studio (completamente sin conexión)

LM Studio 0.3.17+ soporta MCP. Abre la configuración del chat, encuentra la sección Servidores MCP y añade:

{
  "mcpServers": {
    "ucp-local": {
      "command": "/full/path/to/ucp-local",
      "args": ["serve"]
    }
  }
}

Combina UCP con cualquier modelo local que hayas descargado en LM Studio (Llama, Qwen, Mistral, etc.). Ahora tu indexación, incrustaciones, recuperación y modelo de chat se ejecutan todos en la misma máquina — sin nube, sin red — y el LLM aún puede llamar a search_local_context para fundamentar sus respuestas en tus archivos.

Otros clientes MCP

Cualquier cliente que siga la especificación MCP (Zed, Continue.dev, Goose, aplicaciones personalizadas de Agent SDK, etc.) toma la misma forma command + args. Si tu cliente espera un servidor JSON-RPC stdio, apúntalo a ucp-local serve y listo.

Configuración

~/.config/ucp/config.toml (o el equivalente de la plataforma — ucp-local status imprime la ruta resuelta). Todos los campos son opcionales; se muestran los valores predeterminados:

[ollama]
host = "http://localhost:11434"
embedding_model = "nomic-embed-text"

[chunking]
max_tokens = 512
overlap_sentences = 1

Qué se indexa

Por extensión: md, markdown, txt, rs, py, ts, tsx, js, jsx, mjs, go, pdf.

PDFs: el texto se extrae mediante pdf-extract y se fragmenta como prosa. Funciona bien para PDFs generados digitalmente (artículos, documentos, notas exportadas). Falla en PDFs escaneados solo con imágenes — esos necesitan OCR (v0.2+). Los números de línea de las citas hacen referencia al texto plano extraído, no a los números de página del PDF; las citas conscientes de página están en la lista de v0.2.

Directorios omitidos: .git, .idea, .vscode, target, node_modules, __pycache__, .venv, venv, dist, build, .next, .nuxt, coverage, .pytest_cache, .mypy_cache. Los archivos de puntos se omiten.

Arquitectura

Módulo	Rol
ingestion	Enmascaramiento + fragmentadores por formato (prosa / markdown / código mediante tree-sitter) + despachador
storage	rusqlite + sqlite-vec + FTS5; búsqueda híbrida mediante RRF
embeddings	OllamaClient + caché de hash de contenido mediante EmbeddingCache::hash
indexer	Recorrer + leer + fragmentar + incrustar + insertar; rutas de archivo único y fragmentos masivos
watcher	Reindexación con debounce basada en notify
mcp	Servidor JSON-RPC 2.0 stdio, una herramienta: search_local_context

Consulta CLAUDE.md para el resumen de arquitectura orientado a desarrolladores, y Universal Context Pipeline Specification.md para el documento de diseño original (ahora de alcance más reducido).

Desarrollo

cargo test                    # full test suite
cargo test --lib ingestion    # one module
cargo run -- index <path>     # iterate against the dev build
RUST_LOG=ucp_local=info cargo run -- watch <path>   # verbose

Registro de cambios

El historial de versiones y las notas viven en CHANGELOG.md. La versión publicada actual es 0.1.0 (crates.io).

Licencia

Bajo Apache-2.0.