fraise

Fraise

Documentación · Discord · Lenguaje de consulta · Problemas

Fraise es una base de datos de memoria para agentes de IA. Una que consultan directamente, en un lenguaje diseñado para tokens, no para humanos.

remember 'acme moved to annual billing' topic:billing entity:acme

recall billing entity:acme since:30d top:5

Dos verbos. Un binario. Sin infraestructura que ejecutar.

Instalación

brew install fraisehq/tap/fraise
brew services start fraise
curl -X POST localhost:9876/api/v1/q -H 'content-type: application/json' \
  -d "{\"query\": \"remember 'the parrot is turquoise' topic:color\"}"

Paquetes para Linux, Docker, go install y binarios de lanzamiento firmados están todos en Comenzar más abajo.

Lee Durabilidad antes de desplegar. La persistencia es el problema #171 y la siguiente pieza importante de trabajo.

Cómo se compara

Medido en LoCoMo — 10 conversaciones de múltiples sesiones, 1.986 preguntas — con cada sistema ingiriendo las mismas conversaciones, usando el mismo modelo de extracción y el mismo modelo de incrustación, y respondiendo las mismas preguntas. k=10, datos completos, última ejecución por sistema al 2026-10-11.

sistema	recuperación de recuerdo	búsqueda p50	tokens de memoria
fraise 0.3.3	0.910	0.185 s	7.453.109
hindsight 0.9.2	0.913	5.836 s	1.688.873
everos 1.2.3	0.897	0.376 s	10.030.966
letta 0.16.8	0.897	0.349 s	226.854
mem0 2.0.18	0.886	0.576 s	4.120.078
memos 2.0.33	0.865	0.307 s	4.000.552
graphiti 0.30.2	0.828	0.290 s	9.861.973
cognee 1.5.3	0.790	6.273 s	8.526.019
langmem 0.0.30	0.783	0.227 s	1.078.110

Fraise se acerca a 0.003 del mejor recuerdo, 31× más rápido que el único sistema que lo alcanza. Casi la misma evidencia, en una fracción del tiempo. La columna de tokens es el precio de ese recuerdo: el extractor (fraise-sdk 0.2.0) lee cada mensaje junto a lo que el grafo ya contiene, y ese contexto es de donde proviene el recuerdo.

Estos provienen de agent-memory-benchmarks, un arnés abierto — precisión, recuerdo y F1 en k ∈ {1, 3, 5, 10}, por categoría, cada ejecución etiquetada y reproducible desde la etiqueta. Las tablas completas están en su RESULTS.md.

Por qué Fraise

• Un lenguaje de consulta que los agentes realmente pueden escribir. FQL tiene dos verbos — remember y recall — y una forma de decir cada cosa. Menos grados de libertad significa menos formas de que un modelo se equivoque, y menos tokens gastados en decirlo.
• Recuperación híbrida. Los hechos se indexan para búsqueda de texto completo, grafo y (opcionalmente) vectorial. Una consulta, clasificada en los tres.
• Temporal por defecto. Los recuerdos recientes superan a los más antiguos, por lo que el recuerdo es consciente de la actualidad sin pedirlo.
• El sistema más rápido medido. 0.185 s p50 en LoCoMo, por delante de todos los demás sistemas y 31× más rápido que el que tiene un recuerdo equivalente. Recuerda y recupera a mitad de paso, mientras el usuario espera.
• Sin infraestructura. Un solo binario. Sin base de datos que aprovisionar, sin servicio que levantar a su lado.
• Código abierto, MIT.

Estado

v0.3.3. El bucle principal funciona de extremo a extremo y las rutas de instalación están verificadas en máquinas limpias. La fila de referencia anterior se produjo a partir de esta versión. 0.4.0 (finales de octubre) cambia el puntuador y añade explain y describe; 0.5.0 (noviembre) es persistencia y forget.

Adecuado para construir memoria de agente hoy. Aún no para uso de producción a largo plazo.

Cómo funciona

Fraise almacena conocimiento como un grafo de memoria temporal construido a partir de tres tipos de nodos:

• hechos — las cosas que recuerdas, una declaración cada una
• entidades — quién o qué menciona un hecho
• temas — de qué trata un hecho

Las aristas conectan hechos con las entidades que mencionan y los temas sobre los que tratan, por lo que una consulta puede comenzar desde cualquier lado. Un recall encuentra hechos semilla por texto y, opcionalmente, por similitud vectorial; un recuerdo que nombra solo temas o entidades comienza desde los hechos archivados bajo ellos. Con depth:1 o depth:2, un tema o entidad nombrado cuyos hechos coincidieron mejor de lo que su tamaño predice pasa esa evidencia al resto de sus hechos. Los resultados se clasifican por relevancia y actualidad, y los mejores top regresan.

La clasificación no es una caja negra: la puntuación de un hecho es su propia fuerza de coincidencia más lo que recibe a través de anclas que llevan más masa de lo que su tamaño predeciría. La tasa de fondo contra la que se mide ese "más" se estima por consulta, desde la parte del grafo que la consulta tocó, por lo que no hay una constante de relevancia que ajustar. Recuperación híbrida tiene el modelo completo.

Una sola instancia de Fraise contiene varios grafos de memoria independientes (8 por defecto), direccionados con @N — uno por usuario, por sesión, por agente, como prefieras.

Comenzar

Fraise es un solo binario — sin base de datos que aprovisionar, nada que configurar. Cada ruta a continuación te deja con un servidor escuchando en el puerto 9876, en localhost:9876.

Con Homebrew

brew install fraisehq/tap/fraise
brew services start fraise

El servicio sobrevive a fallos y reinicios al iniciar sesión (keep_alive), registra en $(brew --prefix)/var/log/fraise.log, y lee su configuración de $(brew --prefix)/etc/fraise/fraise.config.toml — instalado con cada ajuste comentado en su valor predeterminado, y nunca sobrescrito al actualizar.

Con Docker

docker run -p 127.0.0.1:9876:9876 ghcr.io/fraisehq/fraise:latest

Etiquetas publicadas: una por lanzamiento, latest para la más reciente estable, edge para la punta de main, y una etiqueta inmutable de SHA de commit completo para cada fusión que toca el servidor.

Las imágenes se construyen con procedencia SLSA, verificable sin extraer:

gh attestation verify oci://ghcr.io/fraisehq/fraise:latest --repo FraiseHQ/fraise

Con Go

go install github.com/FraiseHQ/fraise/cmd/server@latest
"$(go env GOPATH)/bin/server"

El binario se instala como server, después de su ruta de paquete — renómbralo a fraise si eso se lee mejor.

No se necesita nada más para confiar en esto: la cadena de herramientas de Go verifica cada descarga de módulo contra el registro público de transparencia de sumas de verificación, y tu propia máquina compila el resultado.

Paquetes de Linux

.deb y .rpm se envían con cada lanzamiento, con una unidad de usuario de systemd:

VERSION=0.3.0
ARCH=$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/')
curl -sSfLO "https://github.com/FraiseHQ/fraise/releases/download/v${VERSION}/fraise_${VERSION}_linux_${ARCH}.deb"
sudo dpkg -i "fraise_${VERSION}_linux_${ARCH}.deb"
systemctl --user enable --now fraise

Los registros van al diario (journalctl --user -u fraise -f), y la unidad lee ~/.config/fraise/fraise.config.toml cuando está presente — un predeterminado enviado con cada ajuste comentado vive en /etc/fraise/fraise.config.toml para copiar. Para agentes que sobreviven a tu sesión de inicio de sesión, deja que el administrador de usuario siga ejecutándose: loginctl enable-linger $USER. Una variante a nivel de sistema (servidor compartido) de la unidad se describe en Ejecutar como servicio gestionado.

Desde un binario de lanzamiento

VERSION=0.3.0
OS=$(uname -s | tr '[:upper:]' '[:lower:]')                # linux | darwin
ARCH=$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/')  # amd64 | arm64
ASSET="fraise_${VERSION}_${OS}_${ARCH}.tar.gz"
BASE="https://github.com/FraiseHQ/fraise/releases/download/v${VERSION}"

curl -sSfLO "${BASE}/${ASSET}"
tar xzf "$ASSET"
./fraise

Las compilaciones de Windows se envían como .zip bajo el mismo esquema de nombres.

Verificar un lanzamiento

Los lanzamientos llevan una firma cosign sobre checksums.txt, usando el mismo VERSION y BASE que arriba:

curl -sSfLO "${BASE}/checksums.txt"
curl -sSfLO "${BASE}/checksums.txt.sigstore.json"

# 1. the bundle proves checksums.txt came from this repo's release workflow
cosign verify-blob \
  --bundle checksums.txt.sigstore.json \
  --certificate-identity-regexp 'https://github.com/FraiseHQ/fraise/.github/workflows/go.yaml@refs/tags/v.*' \
  --certificate-oidc-issuer https://token.actions.githubusercontent.com \
  checksums.txt

# 2. checksums.txt proves your archive is the one it covers
sha256sum --ignore-missing -c checksums.txt   # macOS: shasum -a 256 --ignore-missing -c

Ejecutar desde el código fuente

git clone https://github.com/FraiseHQ/fraise
cd fraise
make dev

Tu primer recuerdo

curl -X POST localhost:9876/api/v1/q \
  -H 'content-type: application/json' \
  -d "{\"query\": \"remember 'the parrot is turquoise' topic:color\"}"

curl -X POST localhost:9876/api/v1/q \
  -H 'content-type: application/json' \
  -d '{"query":"recall parrot"}'

{
  "results": {
    "count": 1,
    "hits": [
      { "value": "the parrot is turquoise", "timestamp": "...", "score": 0.2867 }
    ]
  }
}

Úsalo desde un agente

MCP

fraise mcp es un servidor MCP stdio — un puente delgado hacia un daemon en ejecución, para que cualquier cliente MCP pueda recordar y recuperar. Expone dos herramientas, recall y remember, y no necesita banderas cuando el daemon está en su dirección predeterminada.

Inicia el daemon primero (brew services start fraise, o systemctl --user start fraise en Linux), luego registra el puente con el agente de codificación que uses.

Claude Code

claude mcp add fraise -- fraise mcp

Eso lo registra para el proyecto actual; añade --scope user para hacerlo disponible en cada proyecto en su lugar.

Codex

codex mcp add fraise -- fraise mcp

O escríbelo en ~/.codex/config.toml directamente:

[mcp_servers.fraise]
command = "fraise"
args = ["mcp"]

OpenCode

Añádelo a opencode.json en la raíz de tu proyecto:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "fraise": {
      "type": "local",
      "command": ["fraise", "mcp"]
    }
  }
}

Cualquier otro cliente

{
  "mcpServers": {
    "fraise": { "command": "fraise", "args": ["mcp"] }
  }
}

El puente se describe a sí mismo a través de MCP: cada herramienta llega con una descripción y un esquema JSON completo para sus argumentos y resultados — las formas de FQL, un ejemplo trabajado, qué significa una puntuación — para que un cliente sepa qué hacen recall y remember y cómo llamarlos sin que se le diga. Lo que una descripción de herramienta no puede llevar es la política: el hábito de recurrir a la memoria sin que se le pida, y el juicio sobre qué vale la pena conservar. Eso pertenece al archivo que tu agente ya lee — CLAUDE.md para Claude Code, AGENTS.md para Codex y OpenCode — y dos hábitos son suficientes: recuperar antes de responder cualquier cosa que se apoye en decisiones o preferencias anteriores, y recordar solo hechos que aún importarán en una sesión posterior, un hecho autocontenido por llamada con los temas y entidades que lo harán localizable.

SDKs

Python (sdk/python) — el único SDK hoy:

pip install --pre fraise-sdk

from fraise_sdk import FraiseClient

with FraiseClient("http://localhost:9876") as fraise:
    fraise.remember("the parrot is turquoise", topics=["color"])
    for hit in fraise.recall("parrot", top=5):
        print(hit.value, hit.score)

El SDK de Python es ligero en dependencias y admite búsqueda vectorial cuando proporcionas un incrustador. Consulta su README para incrustaciones y la API completa.

TypeScript — aún no disponible (#179). Hasta que llegue, los usuarios de TypeScript usan fraise mcp o hablan directamente con el endpoint HTTP; son dos verbos sobre una ruta, por lo que un cliente es un envoltorio corto alrededor de fetch. Consulta la API HTTP.

Claude Agent SDK

El SDK de Python incluye herramientas de memoria para el Claude Agent SDK, expuestas como un servidor MCP en proceso para que el agente decida qué almacenar y recuperar:

from claude_agent_sdk import ClaudeAgentOptions
from fraise_sdk import FraiseClient
from fraise_sdk.integrations.claude_agents import memory_server, allowed_tools

fraise = FraiseClient("http://localhost:9876")
options = ClaudeAgentOptions(
    system_prompt="Remember durable facts the user shares, and recall them when relevant.",
    mcp_servers={"fraise_memory": memory_server(fraise)},
    allowed_tools=allowed_tools(),
)

Un agente completo y ejecutable con Docker vive en examples/claude-agent-sdk.

OpenAI Agents SDK

memory_tools(client) devuelve herramientas recall y remember vinculadas:

from agents import Agent, Runner
from fraise_sdk import FraiseClient
from fraise_sdk.integrations.openai_agents import memory_tools

fraise = FraiseClient("http://localhost:9876")
agent = Agent(
    name="Assistant",
    instructions="Remember durable facts the user shares, and recall them when relevant.",
    tools=memory_tools(fraise),
)

result = Runner.run_sync(agent, "My favourite colour is orange.")
print(result.final_output)

Un agente completo y ejecutable con Docker vive en examples/openai-agents.

Referencias

• Hoja de ruta
• Documentación
• Arquitectura
• Gramática del lenguaje de consulta
• Proceso de lanzamiento
• Problemas

Contribuir

Las contribuciones son bienvenidas — consulta CONTRIBUTING.md para saber cómo construir, probar y enviar cambios.

Código de conducta

Este proyecto sigue el Contributor Covenant.

Comunidad

¿Preguntas, ideas o construyendo algo con Fraise? Únete al Discord. Los errores y solicitudes de funciones pertenecen a problemas para que no se pierdan.

Licencia

MIT — consulta LICENSE.