Aleph

Aleph es un servidor MCP y una habilidad para Modelos de Lenguaje Recursivos (RLM, por sus siglas en inglés). Mantiene el estado de trabajo (índices de búsqueda, ejecución de código, evidencia, recursión) en un proceso de Python fuera de la ventana de prompt, de modo que el LLM razona de forma iterativa sobre bases de código grandes, proyectos de larga duración, registros, documentos y datos sin consumir contexto con contenido sin procesar.

+-----------------+    tool calls     +-----------------------------+
|   LLM client    | ---------------> |  Aleph (Python process)     |
| (context budget)| <--------------- |  search / peek / exec / sub |
+-----------------+   small results  +-----------------------------+

Por qué Aleph:

• Carga una vez, razona muchas veces. Los datos viven en la memoria de Aleph, no en el prompt.

• Cómputo del lado del servidor. exec_python ejecuta código sobre el contexto completo y devuelve solo los resultados derivados. Para repositorios JS/TS, exec_javascript y exec_typescript proporcionan un entorno de ejecución de Node.js persistente sobre el mismo ctx.

• Recursión. Las subconsultas y recetas dividen el trabajo complejo en múltiples pasadas de razonamiento.

• Mantén los espacios de trabajo activos. Vincula contextos a archivos o manifiestos de espacio de trabajo generados, actualízalos y retoma investigaciones largas más tarde.

Inicio rápido

pip install "aleph-rlm[mcp]"
aleph-rlm install --profile claude   # or: codex, portable, api
aleph-rlm doctor                     # verify everything is wired up

Luego reinicia tu cliente MCP y confirma que Aleph está disponible:

get_status()
list_contexts()

El atajo de habilidad opcional /aleph (Claude Code) o $aleph (Codex) inicia un flujo de trabajo RLM estructurado. Instala docs/prompts/aleph.md en la carpeta de comandos/habilidades de tu cliente; consulta MCP_SETUP.md para conocer las rutas exactas.

Si estás utilizando herramientas de acción en un repositorio real, la opción predeterminada más segura es:

aleph --enable-actions --action-policy read-only

Cursor

Usa MCP global (aleph-rlm install cursor) para --workspace-mode any, o MCP de proyecto (aleph-rlm install cursor-project desde el repositorio) para ${workspaceFolder} + --workspace-mode fixed. Chat, Composer y la CLI de Cursor comparten esa configuración de MCP; una extensión de Cursor es opcional y no es necesaria para Aleph; consulta MCP_SETUP.md.

Puntos de entrada

Perfiles de instalación

aleph-rlm install pregunta qué perfil de subconsulta usar. Los perfiles configuran el backend anidado que sub_query y sub_query_batch generan para el razonamiento recursivo.

aleph-rlm install claude-code --profile claude
aleph-rlm configure --profile codex   # overwrite existing config

Consulta docs/CONFIGURATION.md para todas las variables de entorno, flags de CLI y opciones de configure(...) en tiempo de ejecución.

Flujo de trabajo para bases de código grandes

Si tu caso de uso principal es un repositorio o un proyecto de varias carpetas, comienza cargando un manifiesto de espacio de trabajo compacto en lugar de arrojar archivos fuente sin procesar en la ventana del modelo. Eso le da al modelo un mapa del proyecto, le permite buscar de forma agresiva y mantiene la sesión actualizable a medida que cambia el repositorio.

load_workspace_manifest(paths=["src", "tests"], context_id="repo")
rg_search(pattern="FastAPI|APIRouter|router\\.", paths=["src", "tests"], load_context_id="routes")
load_file(path="pyproject.toml", context_id="pyproject")
exec_python(code="""
files = [line for line in ctx.splitlines() if line.startswith("- ")]
summary = {
    "indexed_entries": len(files),
    "top_python_files": [line for line in files if "| python |" in line][:10],
}
""", context_id="repo")
get_variable(name="summary", context_id="repo")
refresh_context(context_id="repo")

Usa load_workspace_manifest como puerta de entrada predeterminada para bases de código y proyectos grandes. Luego, incorpora archivos específicos con load_file, busca en el repositorio con rg_search y actualiza el contexto vinculado cuando cambie el espacio de trabajo. Las actualizaciones conservan el estado de razonamiento de la sesión, el registro de evidencia y las tareas rastreadas.

Flujo de trabajo de un solo archivo

Aleph también es potente cuando cargas un archivo grande una vez, realizas el trabajo pesado dentro de Aleph y solo extraes respuestas compactas.

load_file(path="/absolute/path/to/large_file.log", context_id="doc")
search_context(pattern="ERROR|WARN", context_id="doc")
peek_context(start=1, end=60, unit="lines", context_id="doc")
exec_python(code="""
errors = [line for line in ctx.splitlines() if "error" in line.lower()]
result = {
    "error_count": len(errors),
    "first_error": errors[0] if errors else None,
}
""", context_id="doc")
get_variable(name="result", context_id="doc")
save_session(context_id="doc", path=".aleph/doc.json")

El hábito importante es calcular del lado del servidor. No trates get_variable("ctx") como la ruta predeterminada. Busca, filtra, fragmenta o resume primero, luego recupera un resultado pequeño.

Si deseas el modo solo terminal en lugar de MCP, usa:

aleph run "Summarize this log" --provider cli --model codex --context-file app.log

Modelos locales (llama.cpp)

Aleph puede usar un modelo local en lugar de una API en la nube. Esto ejecuta el bucle RLM completo (búsqueda, ejecución de código, convergencia) completamente en tu máquina con un costo de API cero.

Requisitos previos: llama.cpp y un archivo de modelo GGUF.

# Install llama.cpp
brew install llama.cpp          # Mac
winget install ggml.LlamaCpp    # Windows

# Start the server with your model
llama-server -m /path/to/model.gguf -c 16384 -ngl 99 --port 8080

Señala a Aleph el servidor en ejecución:

export ALEPH_PROVIDER=llamacpp
export ALEPH_LLAMACPP_URL=http://127.0.0.1:8080
export ALEPH_MODEL=local
aleph

O deja que Aleph inicie el servidor automáticamente:

export ALEPH_PROVIDER=llamacpp
export ALEPH_LLAMACPP_MODEL=/path/to/model.gguf
export ALEPH_LLAMACPP_CTX=16384
export ALEPH_MODEL=local
aleph

Probado con Qwen 3.5 9B (Q8_0, ~9 GB). Cualquier modelo GGUF funciona: los modelos más grandes dan mejores resultados en el bucle RLM. Los modelos con soporte de razonamiento/pensamiento (Qwen 3.5, QwQ, etc.) se manejan automáticamente. Consulta CONFIGURATION.md para todas las variables ALEPH_LLAMACPP_*.

Cargas de trabajo comunes

Herramientas principales

REPL de Python vs JS/TS

La capa de control principal de Aleph sigue siendo Python. exec_python sigue siendo el REPL predeterminado para análisis de propósito general, recetas y orquestación.

• Usa exec_python cuando necesites toda la superficie de Aleph: prompts centrados en Python, la pila numérica/simbólica de Python (cmath, mpmath, decimal, fractions, statistics, numpy, scipy, sympy, networkx) o ejecución de recetas mediante run_recipe_code.

• Usa exec_javascript / exec_typescript cuando el repositorio o análisis de destino tenga una forma natural de JS/TS y desees un estado de Node persistente, manipulación de arreglos/objetos nativa de JS o recursión asíncrona con await.

• exec_python Superficie completa de ayudantes de Aleph, incluidos ayudantes de DSL de recetas, sub_query(...) / sub_aleph(...) síncronos y la mayor compatibilidad con prompts y flujos de trabajo existentes.

• exec_javascript / exec_typescript Entorno de ejecución de Node.js persistente por contexto para repositorios con mucho JS/TS. Comparte el mismo ctx, admite await de nivel superior y puede recurrir con await sub_query(...), await sub_query_batch(...), await sub_query_map(...), await sub_query_strict(...) y await sub_aleph(...). También incluye el DSL de recetas (Recipe, Search, Take, etc.) para construir cargas útiles de recetas en JS/TS.

El entorno de ejecución de JS/TS también se envía con un conjunto de ayudantes locales más amplio que la primera parte de entrega: búsqueda/peek/líneas/fragmentos, ayudantes de extracción (extract_emails, extract_todos, extract_routes, etc.), utilidades de texto (number_lines, grep_v, sort_lines, normalize_whitespace, etc.), ayudantes de comparación de texto (diff, similarity, common_lines, diff_lines), ayudantes de colección (flatten, group_by, frequency, sample_items, shuffle_items, etc.), ayudantes de validación (is_json, is_email, is_uuid, etc.), convertidores de CSV/JSON y semantic_search.

El entorno de ejecución de JS/TS ahora también incluye el DSL de recetas: RecipeStep, RecipeBuilder y todos los constructores de pasos (Recipe, Search, Peek, Lines, Take, Chunk, Filter, MapSubQuery, SubQuery, Aggregate, Assign, Load, Finalize, as_recipe). Puedes construir recetas con encadenamiento fluido o estilo tubería:

// Fluent style
Recipe("doc").search("ERROR").take(5).finalize().compile()

// Pipe style
Recipe("doc").pipe(Search("ERROR")).pipe(Take(5)).pipe(Finalize()).compile()

Las herramientas MCP compile_recipe y run_recipe_code aceptan un parámetro language ("python", "javascript", "typescript") para compilar código DSL de recetas en el entorno de ejecución correspondiente.

Lo que aún difiere de Python:

• Python sigue siendo el REPL de Aleph predeterminado y mejor soportado.

• Los ayudantes de recursión de JS/TS son asíncronos y requieren await.

• La ejecución de recetas (run_recipe) siempre utiliza el entorno de ejecución de Python. La ruta JS/TS cubre solo la construcción y compilación de recetas.

• JS usa RecipeBuilder.pipe() / métodos fluidos en lugar del operador | de Python (el | de JS es OR a nivel de bits, no sobrecargable para este propósito).

• El ecosistema de importación de Python sigue siendo solo para Python. El entorno de ejecución de Node está basado en ayudantes: no hay require, no hay process, no hay module y no hay carga de paquetes npm dentro del sandbox.

• exec_typescript elimina la sintaxis de tipos para la ejecución; no es un compilador de TS completo, verificador de tipos o entorno ts-node.

• El comportamiento de los flags de Regex sigue a cada entorno de ejecución: los ayudantes de Python usan flags re de Python, mientras que los ayudantes de JS/TS usan cadenas de flags de regex de JavaScript.

Ejemplo de flujo de trabajo JS/TS:

exec_typescript(code=`
const routes: string[] = extract_routes('javascript').map((item) => item.value);
const routeKinds = frequency(
  routes.map((route) => (route.includes('.post(') ? 'write' : 'read')),
  2,
);
const notes = await sub_query_map(
  routes.map((route) => `Explain ${route}`),
  routes,
);
({ routeCount: routes.length, routeKinds, notes })
`, context_id="repo")

Modelo de seguridad

Aleph está diseñado para mantener el contexto sin procesar fuera de la ventana del modelo a menos que lo extraigas explícitamente:

• Las respuestas de las herramientas están limitadas y truncadas.

• get_variable("ctx") es consciente de las políticas y no debería ser tu ruta predeterminada.

• stdout, stderr y los valores de retorno de exec_python están limitados de forma independiente.

• ALEPH_CONTEXT_POLICY=isolated añade reglas de exportación/importación de sesión más estrictas y valores predeterminados más defensivos.

• ALEPH_ACTION_POLICY=read-only (o --action-policy read-only) mantiene las herramientas de acción en modo de solo lectura: la búsqueda y la carga de archivos siguen funcionando, pero las escrituras y la ejecución de subprocesos están bloqueadas.

El patrón más seguro es siempre:

1. Cargar el contexto grande en la memoria de Aleph.

2. Buscar o calcular dentro de Aleph.

3. Recuperar solo el resultado pequeño que necesitas.

Mapa de documentos

• MCP_SETUP.md: instalación de MCP y habilidades cliente por cliente.

• docs/prompts/aleph.md: el flujo de trabajo /aleph y $aleph más patrones de herramientas.

• docs/CONFIGURATION.md: flags, variables de entorno, límites y configuraciones de seguridad.

• docs/langgraph-rlm-default.md: integración de LangGraph con el uso de herramientas al estilo Aleph.

• examples/langgraph_rlm_repo_improver.py: ejemplo de mejora de repositorio con rastreo opcional de LangSmith.

• CHANGELOG.md: historial de versiones.

• DEVELOPMENT.md: guía para colaboradores.

Desarrollo

git clone https://github.com/Hmbown/aleph.git
cd aleph
pip install -e ".[dev,mcp]"
# Optional extras:
#   .[docs]           -> MarkItDown-backed document conversion
#   .[observability]  -> OpenTelemetry spans
pytest tests/ -v
ruff check aleph/ tests/

Referencias

• Zhang, A. L., Kraska, T., Khattab, O. (2025) Recursive Language Models (arXiv:2512.24601)

Licencia

MIT