Friday

Friday

Capa de memoria cognitiva persistente autoalojada para agentes de codificación de IA.

Persiste decisiones de arquitectura, esquemas y restricciones entre sesiones mediante el Protocolo de Contexto de Modelo (MCP).

El Problema

Arquitectura

Doble Motor

Ciclo de Vida de la Memoria

Inicio Rápido

SDK de Python

Configuración de MCP

Reglas del Agente

Referencia de API

_{Friday Neural Studio — Visualizador de grafos de conocimiento 3D en tiempo real con WebGL que renderiza topologías de servicios, mapas de calor de acceso dinámicos y consolidación automatizada de memoria.}

El Problema: Amnesia de Sesión

Los agentes modernos de codificación de IA (Cursor, Claude Code, Antigravity, VS Code) sobresalen en la generación de código aislado. Sin embargo, en flujos de trabajo de ingeniería continua, los desarrolladores se enfrentan a una limitación estructural: Amnesia de Sesión.

Las soluciones actuales caen en tres patrones profundamente defectuosos:

                  ┌─────────────────────────────────────────────────────────┐
                  │          WHY STANDARD APPROACHES BREAK DOWN             │
                  └─────────────────────────────────────────────────────────┘

   1. Context Windows (RAM)           2. Static Rules Files             3. Standard Vector RAG
  ┌─────────────────────────┐       ┌─────────────────────────┐       ┌─────────────────────────┐
  │ • Ephemeral volatile    │       │ • Linear token tax      │       │ • Matches text phrasing,│
  │   memory (clears on     │       │   (2,500 tokens burned  │       │   NOT system topology   │
  │   every new thread)     │       │   on every trivial fix) │       │ • Blind to directed     │
  │ • Lost-in-the-middle    │       │ • Stale rules accumu-   │       │   call graphs & schema  │
  │   degradation on 50k+   │       │   late & conflict       │       │   dependencies          │
  │   token prompts         │       │ • Zero cross-tool sync  │       │ • Hallucinates blast    │
  │ • High latency & cost   │       │   (Cursor ≠ Claude CLI) │       │   radii of refactors    │
  └─────────────────────────┘       └─────────────────────────┘       └─────────────────────────┘

1. Las Ventanas de Contexto Son Volátiles: Las ventanas de contexto actúan como RAM de trabajo, no como almacenamiento duradero. Limpiar un hilo o reiniciar un agente restablece el estado. Rellenar el prompt con 50k+ tokens introduce la caída de atención "perdido en el medio" y aumenta la latencia de inferencia.
2. Los Archivos de Reglas Estáticos Imponen un Impuesto Lineal de Tokens: Mantener archivos de reglas grandes (.cursorrules, AGENTS.md) obliga al modelo a releer miles de líneas en cada pulsación de tecla, lo que genera instrucciones contradictorias y fragmentación entre editores.
3. La Búsqueda Vectorial Omite la Topología del Sistema: La similitud de coseno de embeddings coincide con la redacción del texto, no con las dependencias relacionales. La búsqueda vectorial no puede recorrer grafos dirigidos: $$\text{Tabla: accounts} \longrightarrow \text{FK: subscriptions} \longrightarrow \text{Servicio: BillingService} \longrightarrow \text{Trabajador: InvoicePoller}$$

Arquitectura: Sustrato Cognitivo Multicapa

Friday se ejecuta como un servicio de fondo autoalojado que proporciona un sustrato de memoria estructurado de cuatro niveles, accesible mediante el Protocolo de Contexto de Modelo (MCP):

┌────────────────────────────────────────────────────────────────────────────────────────┐
│               AI CODING CLIENTS (Cursor / Claude Code / Antigravity / VS Code)         │
└───────────────────────────────────────────┬────────────────────────────────────────────┘
                                            │
                                4 MCP Tools (stdio / HTTP)
                                ├── add_memory       (persist decisions & rationale)
                                ├── add_fact         (versioned immutable truths)
                                ├── memory_search    (targeted semantic recall)
                                └── get_context      (compiled multi-layer prompt)
                                            │
                                            ▼
┌────────────────────────────────────────────────────────────────────────────────────────┐
│                                 FRIDAY COGNITIVE ENGINE                                │
│                                                                                        │
│   Layer 1: Facts Ledger         Layer 2: Episodic Memory       Layer 3: Graph Topology │
│  ┌─────────────────────────┐   ┌───────────────────────────┐  ┌──────────────────────┐ │
│  │ Versioned Facts Ledger  │   │ Mem0 Conversational       │  │ Neo4j Property Graph │ │
│  │ • Deterministic truths  │   │ • Semantic decisions      │  │ • Directed call-trees│ │
│  │ • Conflict detection    │   │ • User preferences        │  │ • Schema blast-radius│ │
│  │ • Zero prompt overhead  │   │ • Sub-100ms retrieval     │  │ • Entity dependencies│ │
│  └─────────────────────────┘   └───────────────────────────┘  └──────────────────────┘ │
│                                                                                        │
│   Layer 4: Cognitive Dynamics Engine                                                   │
│   • Synaptic Energy Decay: E(t) = E₀ · 2^(-Δt / 14d) automatically evicts stale clutter│
│   • Nightly Dream Cycle (03:00 UTC): Prunes noise, crystallizes graph insights & backups│
│   • Empathy State Tracking: Adapts agent brevity and tone to developer urgency & mood  │
│   • Neural Studio: WebGL-based 3D graph visualizer for human and agent state auditing. │
│   • Persona Synchronization: /export/persona compiles canonical rules on-demand.       │
└────────────────────────────────────────────────────────────────────────────────────────┘

Las 4 Capas de Memoria Explicadas:

Matriz de Comparación Arquitectónica

Arquitectura de Doble Motor: Procesamiento de Fondo Desacoplado

Una decisión arquitectónica fundamental en Friday es:

"¿Por qué Friday mantiene un LLM de trabajador de fondo (como Groq, DeepSeek u Ollama local) en el servidor, completamente separado del modelo frontera que se ejecuta en Cursor, Claude Code o Antigravity?"

Los agentes de codificación interactivos requieren baja latencia, mientras que el mantenimiento del grafo de conocimiento requiere extracción y síntesis continua de datos. Friday impone una Arquitectura de Doble Motor que desacopla limpiamente los flujos de trabajo de los desarrolladores de primera línea de los pipelines de datos de fondo:

┌────────────────────────────────────────────────────────────────────────────────────────┐
│                        THE DUAL-ENGINE ARCHITECTURE MODEL                                 │
├────────────────────────────────────────────────────────────────────────────────────────┤
│                                                                                        │
│   INTERACTIVE AGENT (Frontline Client)       BACKGROUND WORKER (Async Engine)      │
│   ┌─────────────────────────────────────┐     ┌─────────────────────────────────────┐  │
│   │ Client: Cursor / Claude / Antigravity│     │ Engine: Self-Hosted Friday Server   │  │
│   │ Model: Frontier (Claude 3.5 / GPT-4o)│     │ Model: Fast Worker (Groq / Ollama)  │  │
│   │ Role: Complex code generation       │     │ Role: Async graph extraction        │  │
│   │ Context: Lean, task-specific prompt │     │ Role: Conflict pruning & decay      │  │
│   │ State: Ephemeral session lifetime   │     │ State: 24/7 background persistent   │  │
│   └──────────────────┬──────────────────┘     └──────────────────▲──────────────────┘  │
│                      │                                           │                     │
│                      │ 1. MCP Tools (memory_search, add_memory)  │ 2. Microsecond      │
│                      ▼                                           │    Async Parsing    │
│   ┌──────────────────────────────────────────────────────────────┴──────────────────┐  │
│   │                        FRIDAY PERSISTENT MEMORY ARCHITECTURE                    │  │
│   │                                                                                 │  │
│   │   Layer 1: Facts Ledger (Deterministic S3-style Hash Table)                     │  │
│   │   Layer 2: Episodic Memory (Mem0 Conversational Thread History)                 │  │
│   │   Layer 3: Vector Embeddings (ChromaDB Semantic Chunks)                         │  │
│   │   Layer 4: Property Knowledge Graph (Neo4j Directed Topology)                   │  │
│   │   Memory Lifecycle: Dynamic Decay (E(t)) & Nightly Dream Cycle (03:00 UTC)    │  │
│   └─────────────────────────────────────────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────────────────────────────────────────┘

Por Qué el Desacoplamiento del Procesamiento de Fondo es Esencial:

1. ⚡ Ejecución de IDE de Cero Latencia (Desacoplamiento No Bloqueante)

Cuando escribes en Cursor o Claude Code y un agente registra una decisión importante mediante add_memory, el modelo Consciente no puede pausarse durante 4–6 segundos mientras un LLM analiza entidades semánticas, identifica claves foráneas y ejecuta mutaciones Cypher.

• Con el trabajador Subconsciente desacoplado de Friday, la llamada MCP responde en < 40ms.
• El motor Subconsciente (p. ej., Groq ejecutando Llama-3 a 500+ tokens/seg) consume el evento de forma asíncrona, conectando nodos y relaciones del grafo en segundo plano sin robar ni un milisegundo del flujo del desarrollador.

2. 💰 Optimización de Costos de Tokens del 95%+

Los modelos de razonamiento frontera (Claude 3.5 Sonnet, GPT-4o) cuestan $3.00 a $15.00 por millón de tokens. Usar estos modelos costosos para mantenimiento estructural rutinario—como extraer tripletas (Entity A $\longrightarrow$ RELATION $\longrightarrow$ Entity B), verificar hashes de hechos o aplicar decaimiento sináptico—desperdicia presupuestos masivos de tokens.

• Friday descarga las tareas estructurales a APIs de fondo ultrarrápidas y ultrabaratas (Groq, DeepSeek Flash) o a modelos autoalojados completamente gratuitos (Ollama, vLLM).
• Tu modelo frontera solo gasta tokens en lo que importa: resolver problemas complejos de ingeniería.

3. 🌙 Consolidación de Fondo Autónoma (El Ciclo de Sueño)

Tu sesión de codificación termina cuando cierras tu IDE o pones tu portátil en reposo. Pero la evolución de la memoria no puede detenerse cuando el portátil se cierra:

• El motor Subconsciente de Friday vive en tu servidor en la nube o local 24/7.
• A las 03:00 UTC cada noche, mientras duermes, el Subconsciente se despierta para ejecutar el Ciclo de Sueño: calcular el decaimiento sináptico, podar ruido de baja energía, destilar aprendizajes episódicos diarios en hechos estratégicos permanentes y confirmar instantáneas cifradas en Git.

4. 🛡️ Defensa contra Alucinaciones y Contaminación del Contexto

Volcar un grafo monolítico de 500 nodos o 100 decisiones históricas directamente en el prompt de tu editor causa Dilución de Instrucciones: el LLM se confunde, olvida restricciones recientes y alucina patrones obsoletos.

• El Subconsciente actúa como un firewall inteligente.
• Digiere el contexto bruto, resuelve contradicciones, calcula el decaimiento de energía ($E(t)$) y sirve solo los hechos cristalizados de alta energía directamente relevantes para tu tarea activa (~280 tokens en lugar de 5,000).

Gestión del Ciclo de Vida de la Memoria: Decaimiento, Consolidación y Calibración

Friday implementa una gestión activa del ciclo de vida de la memoria para garantizar que los agentes de IA retengan restricciones críticas sin inflar el contexto ni interferir con instrucciones obsoletas:

┌────────────────────────────────────────────────────────────────────────────────────────┐
│                          FRIDAY MEMORY LIFECYCLE ENGINE                                │
├────────────────────────────────────────────────────────────────────────────────────────┤
│                                                                                        │
│  🔥 Dynamic Memory Heat & Decay           🌙 The Dream Cycle (Nightly 03:00 UTC)      │
│  ┌───────────────────────────────────┐    ┌────────────────────────────────────────┐   │
│  │ Exponential Synaptic Decay        │    │ 1. Synaptic Pruning (Evaporates noise) │   │
│  │ • E(t) = E₀ · 2^(-Δt / T_half)    │───>│ 2. Episodic Synthesis (Distills gems)  │   │
│  │ • Recall Potentiation (+0.25)     │    │ 3. Neo4j Crystallization (Graph edges) │   │
│  │ • Soft Archive if E < 0.25        │    │ 4. Autonomous Backup to Git            │   │
│  └───────────────────────────────────┘    └────────────────────────────────────────┘   │
│                                                                                        │
│  🤍 Adaptive Context & Persona Calibration                                             │
│  ┌──────────────────────────────────────────────────────────────────────────────────┐  │
│  │ Multi-Dimensional Response Calibration                                           │  │
│  │ • Interaction Modes: tactical_sprint | deep_architecture | casual_brainstorm     │  │
│  │ • Task Context & Urgency Detection (0.0 to 1.0)                                  │  │
│  │ • Dynamic Response Calibration: Brevity (high/med/low) & Tone Tuning             │  │
│  └──────────────────────────────────────────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────────────────────────────────────────┘

1. 🔥 Calor y Decaimiento Dinámico de la Memoria

Los recuerdos y hechos verificados no son texto estático—tienen energía. Las directivas activas y consultadas con frecuencia permanecen brillantes ($E > 1.0$). Los detalles irrelevantes u obsoletos experimentan un decaimiento exponencial de vida media ($T_{half} = 14\text{ días}$): $$E(t) = E_0 \times 2^{-\frac{\Delta t}{T_{half}}}$$ Cuando se consulta un recuerdo durante la codificación, recibe un impulso de potenciación por recuperación ($+0.25$), evitando que el conocimiento obsoleto abarrote el prompt del agente mientras preserva los invariantes arquitectónicos centrales (decay_immune: True).

2. 🌙 El Ciclo de Sueño

Cada noche a las 03:00 UTC (o bajo demanda mediante client.run_dream_cycle()), Friday entra en el Ciclo de Sueño:

• Poda Sináptica: Identifica hechos fríos/obsoletos y los transiciona a almacenamiento archivado.
• Síntesis Episódica: Agrupa conversaciones recientes y destila 1–2 ideas estratégicas cristalizadas.
• Cristalización en Neo4j: Vincula ideas de alta confianza en el grafo de propiedades con aristas CRYSTALLIZED_INTO.
• Sincronización Autónoma con Git: Activa confirmaciones automáticas del repositorio que preservan instantáneas del grafo.

3. 🤍 Calibración Adaptativa de Contexto y Persona

Friday monitorea el contexto de interacción del desarrollador (sprint urgente de corrección de errores, exploración arquitectónica nocturna o lluvia de ideas informal). El motor ajusta dinámicamente las características de respuesta del agente:

• Calibración de Brevedad: high (sin relleno, código primero) vs. detailed (desglose a nivel de sistema).
• Calibración de Tono: technical_concise (código primero, directo) vs. architectural_detailed (desglose a nivel de sistema).
• Se inyecta automáticamente en /export/persona para que todos los agentes calibren naturalmente su salida.

Benchmarks de DeepEval

Evaluamos cinco escenarios de ingeniería realistas utilizando el marco de evaluación DeepEval:

1. Radio de Explosión del Esquema de Base de Datos (evaluando el recorrido del grafo de llamadas descendente)
2. Ciclo de Vida de Refresco de Autenticación (evaluando la fidelidad de restricciones versionadas)
3. Garantía de Idempotencia de Webhooks (evaluando casos límite de condiciones de carrera)
4. Reservas de Entorno y Puertos (evaluando la recuperación de verdades estáticas)
5. Consistencia del Conjunto de Herramientas Multiagente (evaluando la sincronización entre herramientas en Cursor y Claude CLI)

Reproduciendo Benchmarks Localmente

python benchmarks/benchmark_deepeval.py

Inicio Rápido

Opción A: Instalación con un Solo Comando (Recomendada)

Ejecuta el script de instalación autocontenido:

curl -fsSL https://raw.githubusercontent.com/friday-memory/friday/main/install.sh | bash

El script verifica la disponibilidad de Docker, asigna los puertos requeridos (8000, 7474, 7687), genera secretos de API aleatorios y seguros, escribe un .env validado y lanza Friday mediante Docker Compose.

Opción B: Configuración Manual mediante Docker Compose

1. Clonar el Repositorio:

   git clone https://github.com/friday-memory/friday.git
   cd friday
   

2. Configurar el Entorno (.env):

   cp .env.example .env
   

   # Master API key for endpoint security
   BRAIN_API_KEY=choose_a_strong_secret_key
   
   # Fast Subconscious LLM provider (Groq or DeepSeek)
   DEEPSEEK_API_KEY=your_key_here
   DEEPSEEK_BASE_URL=https://api.deepseek.com
   DEEPSEEK_MODEL=deepseek-chat
   
   # Mem0 key for vector memory (optional)
   MEM0_API_KEY=your_mem0_key_here
   
   # Neo4j database credentials
   NEO4J_URI=bolt://neo4j:7687
   NEO4J_USER=neo4j
   NEO4J_PASSWORD=choose_a_strong_password
   

3. Iniciar el Stack:

   make up
   # or: docker compose up -d
   

4. Verificar el Estado de Salud:

   curl http://localhost:8000/health
   

   {
     "status": "healthy",
     "service": "friday-cognitive-substrate",
     "version": "1.4.4",
     "layers": {
       "L1_core": "healthy",
       "L2_mem0": "healthy",
       "L3_chromadb": "healthy",
       "L4_neo4j": "healthy"
     }
   }
   

SDK de Python (friday-memory)

El cliente oficial de Python para Friday está disponible en PyPI como friday-memory. Conecta tus flujos de trabajo de agentes, pipelines de LangChain o scripts autónomos directamente a Friday sin código repetitivo:

pip install --upgrade friday-memory

Cliente Síncrono

from friday import Friday

# Automatically resolves FRIDAY_URL and FRIDAY_API_KEY from environment
with Friday(api_key="your_secret_key", base_url="http://localhost:8000") as client:
    # 1. Health check
    status = client.health()
    print("Friday Status:", status["status"])

    # 2. Store architectural decision
    client.add_memory(
        "PostgreSQL 16 selected with pgvector for hybrid retrieval",
        project="backend-api",
    )

    # 3. Commit scoped ground-truth fact with auto-conflict resolution
    client.add_fact("Production database endpoint is db.internal.net:5432", project="backend-api")

    # 4. Query multi-hop dependency blast radius before refactoring
    blast = client.get_blast_radius(entity="OrdersTable", depth=2, project="backend-api")
    print(
        f"Impacted components ({blast['total_impacted']}):",
        [n["name"] for n in blast["impacted_nodes"]],
    )

    # 5. Multi-layer search (L2 Facts + L3 ChromaDB + L4 Knowledge Graph)
    context = client.search("database connection configuration", project="backend-api")
    print(context["results"])

    # 5. Cognitive State & Dynamic Response Calibration
    state = client.get_cognitive_state()
    print("Active Mode:", state["current_mode"])  # tactical_sprint, deep_architecture, etc.

    # 6. Trigger Nightly Dream Cycle Consolidation (Consolidates & Prunes)
    dream_report = client.run_dream_cycle(half_life_days=14.0)
    print("Crystallized Insights:", dream_report["crystallized_insights"])

    # 7. Apply Synaptic Decay
    decay_report = client.apply_decay(half_life_days=14.0)
    print("Active Facts Remaining:", decay_report["active_facts_count"])

Cliente Asíncrono (FastAPI / Agentes de Trabajo)

import asyncio
from friday import AsyncFriday


async def main():
    async with AsyncFriday(api_key="your_secret_key") as client:
        # Commit context concurrently
        await client.add_memory("Redis cluster deployed for token bucket rate limiting")
        facts = await client.get_facts(min_energy=0.5)
        print(f"Verified high-energy facts: {len(facts)}")


asyncio.run(main())

Integración con LangChain (FridayRetriever)

pip install "friday-memory[langchain]"

from friday.integrations.langchain import FridayRetriever
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI

retriever = FridayRetriever(
    api_key="your_secret_key",
    base_url="http://localhost:8000",
    project="reeldm",
)

# Connect directly to LCEL chains
prompt = ChatPromptTemplate.from_template(
    "Answer using verified system memory:\n{context}\n\nQuestion: {question}"
)

chain = {"context": retriever, "question": RunnablePassthrough()} | prompt | ChatOpenAI()

Configuración del Cliente (MCP)

Friday proporciona un servidor oficial de Model Context Protocol (MCP) sobre stdio o HTTP, lo que permite la recuperación de contexto en tiempo real para todos los IDEs compatibles.

 ┌───────────────────────┐
 │   Cursor (Desktop)    │──┐
 └───────────────────────┘  │
 ┌───────────────────────┐  │
 │    Claude Code CLI    │──┼── MCP Protocol (stdio transport)
 └───────────────────────┘  │   FRIDAY_URL="http://127.0.0.1:8000"
 ┌───────────────────────┐  │   BRAIN_API_KEY="your_secret_key"
 │    Antigravity IDE    │──┤
 └───────────────────────┘  │
 ┌───────────────────────┐  │
 │  Windsurf / VS Code   │──┤
 └───────────────────────┘  │
 ┌───────────────────────┐  │
 │       Codex CLI       │──┘
 └───────────────────────┘
                            ▼
             ┌──────────────────────────────┐
             │     FRIDAY CENTRAL BRAIN     │
             │   (Localhost or Remote VM)   │
             │   FastAPI + Mem0 + Neo4j     │
             └──────────────────────────────┘

{
  "mcpServers": {
    "friday": {
      "command": "python",
      "args": ["-m", "mcp.server"],
      "cwd": "/path/to/friday",
      "env": {
        "FRIDAY_URL": "http://localhost:8000",
        "BRAIN_API_KEY": "your_secret_key"
      }
    }
  }
}

{
  "mcpServers": {
    "friday": {
      "command": "ssh",
      "args": [
        "-i", "/path/to/ssh_key.pem",
        "-o", "StrictHostKeyChecking=no",
        "ubuntu@YOUR_SERVER_IP",
        "docker exec -i fridays-brain-app python /app/mcp_server/server.py"
      ]
    }
  }
}

claude mcp add friday \
  -e FRIDAY_URL="http://localhost:8000" \
  -e BRAIN_API_KEY="your_secret_key" \
  -- python -m mcp.server

{
  "mcpServers": {
    "friday": {
      "command": "python",
      "args": ["-m", "mcp.server"],
      "cwd": "/path/to/friday",
      "env": {
        "FRIDAY_URL": "http://localhost:8000",
        "BRAIN_API_KEY": "your_secret_key"
      }
    }
  }
}

[mcp.servers.friday]
command = "python"
args = ["-m", "mcp.server"]
cwd = "/path/to/friday"

[mcp.servers.friday.env]
FRIDAY_URL = "http://localhost:8000"
BRAIN_API_KEY = "your_secret_key"

{
  "cline.mcpServers": {
    "friday": {
      "command": "python",
      "args": ["-m", "mcp.server"],
      "cwd": "/path/to/friday",
      "env": {
        "FRIDAY_URL": "http://localhost:8000",
        "BRAIN_API_KEY": "your_secret_key"
      }
    }
  }
}

Referencia de Herramientas

Los agentes conectados acceden automáticamente a cuatro primitivas MCP principales:

Referencia de Variables de Entorno

Exportación de Directivas Dinámicas (/export/persona)

Friday puede compilar hechos almacenados y restricciones arquitectónicas en directivas de markdown sincronizadas bajo demanda, evitando la deriva de reglas entre equipos:

# Export canonical AGENTS.md
curl -s "http://localhost:8000/export/persona?target=agents" \
  -H "X-Brain-Key: your_key" > AGENTS.md

# Export Cursor .cursorrules
curl -s "http://localhost:8000/export/persona?target=cursor" \
  -H "X-Brain-Key: your_key" > .cursorrules

Motor Universal de Directivas para Agentes (Reglas Multi-Agente)

Diferentes asistentes de codificación de IA dependen de diferentes formatos de instrucciones de espacio de trabajo. Friday incluye un motor CLI integrado que genera directivas de memoria estandarizadas y bidireccionales para cualquier editor o ejecutor de agentes autónomos:

1. Listar Destinos Compatibles

friday rules list

2. Generar Reglas para tu Cadena de Herramientas

Genera un archivo de reglas optimizado para un agente específico:

friday rules generate --target claude
friday rules generate --target cursor
friday rules generate --target gemini

O genera archivos de reglas estandarizados para todas las herramientas compatibles a la vez:

friday rules generate --all

3. Adaptadores de Agentes Personalizados Extensibles

Para agentes propietarios, herramientas corporativas internas o frameworks recién lanzados, registra y genera archivos de reglas adaptados personalizados:

friday rules custom \
  --key myagent \
  --name "Internal SRE Agent" \
  --file ".myagent/rules.md"

Cada archivo de reglas generado aplica el Protocolo Bidireccional de Cero Amnesia:

• Puerta de Lectura Previa a la Tarea: Consulta automáticamente friday:get_context y friday:memory_search antes de formular planes de implementación.
• Puerta de Escritura Posterior a la Tarea: Persiste automáticamente decisiones arquitectónicas, esquemas y correcciones de errores mediante friday:add_fact y friday:add_memory.

Características

1. Extracción Automatizada de Grafos de Conocimiento

Cada memoria escrita mediante add_memory se analiza de forma asíncrona por el trabajador Subconscious. Las entidades y relaciones tipadas se conectan automáticamente en Neo4j sin definiciones de esquema manuales:

Input:
"Billing engine connects to Stripe API for recurring charges. Webhook dispatched to /api/webhooks/stripe."

Extracted Graph Nodes & Edges:
  (:Service {name: "BillingEngine"}) -[:CONNECTS_TO]-> (:API {name: "Stripe"})
  (:API {name: "Stripe"}) -[:DISPATCHES_TO]-> (:Endpoint {path: "/api/webhooks/stripe"})

2. Neural Studio (Visualizador de Grafos 3D Interactivo)

Un visualizador 3D WebGL basado en navegador impulsado por Three.js para la exploración de grafos de conocimiento en tiempo real y telemetría del sistema:

• Diseño Agrupado por Dominio: Agrupa entidades por dominio arquitectónico (API, Servicios, Almacenamiento, Autenticación, Infraestructura) para evitar enredos visuales en más de 1,000 nodos y aclarar los límites de los servicios.
• Mapa de Calor de Acceso Dinámico: Colorea nodos por frecuencia y actualidad de recuperación, con filtros interactivos para directivas activas (Hot ≥ 0.7) y contexto antiguo/obsoleto (Decayed < 0.4).
• Consolidación de Memoria con 1 Clic: Envía la consolidación de memoria en segundo plano directamente desde la interfaz, sintetizando conversaciones episódicas y cristalizando relaciones Neo4j verificadas.
• HUD de Estado en Vivo: Indicador en tiempo real que muestra el modo operativo activo (Sprint, Arquitectura Profunda, Lluvia de Ideas) y el estado del sistema.
• Inspector de Nodos Interactivo: Inspecciona metadatos, refuerza pesos de prioridad (+0.25), rastrea cadenas de relaciones bidireccionales y enfoca suavemente la cámara 3D en nodos objetivo.
• CRUD en Vivo y Exportación de Topología: Crea, renombra o vincula entidades de forma interactiva, y exporta capturas de lienzo de alta resolución para documentación del sistema.

3. Libro de Contabilidad de Hechos Versionado y Resolución Inteligente de Conflictos

Las constantes deterministas del proyecto se registran con historial de versiones inmutable y aislamiento de proyectos (reeldm, friday, global). Las claves conflictivas (Key: Value) reemplazan automáticamente versiones anteriores dentro del mismo espacio de nombres del proyecto:

# Add initial constraint (project-scoped)
POST /facts -> {"content": "Payment Gateway: Stripe", "project": "billing"}
# Recorded: id="c41b8a9", superseded=false

# Update constraint — automatically detects conflicting key 'Payment Gateway'
POST /facts -> {"content": "Payment Gateway: DodoPayments", "project": "billing"}
# Prior fact marked superseded=true; active fact updated without hallucination.

4. Análisis de Radio de Impacto de Dependencias

Antes de modificar esquemas de bases de datos, refactorizar middleware compartido o eliminar endpoints, los agentes consultan get_blast_radius para calcular impactos transitivos posteriores hasta 4 saltos en la Capa 4:

# Query blast radius for a service or entity
GET /graph/blast-radius?entity=UserSession&depth=2&project=backend-api
# Returns: directly impacted services, traversal distance, and edge relationship types.

Estructura del Repositorio

friday/
├── friday/                  # Official Python SDK & CLI (client, rules engine, types)
├── gateway/                 # FastAPI REST application & routing (Neo4j + ChromaDB + Mem0)
├── layers/                  # Pluggable cognitive adapters (ChromaDB, Neo4j, Decay)
├── pipelines/               # Background entity extraction, Dream Cycle & fact pipelines
├── orchestrator/            # Multi-layer retrieval router & cognitive state engine
├── mcp/                     # Model Context Protocol stdio server
├── studio/                  # Three.js Neural Studio 3D visualizer
├── benchmarks/              # DeepEval evaluation suite
├── tests/                   # Pytest test suite (100% green)
├── docker-compose.yml       # Production container definition
├── Makefile                 # Developer task automation
└── pyproject.toml           # Tooling & packaging configuration

Referencia de la API

Todos los endpoints autenticados requieren el encabezado de solicitud X-Brain-Key.

Desarrollo

# Install dependencies
make install

# Run test suite
make test

# Code formatting & linting
make lint
make format

# Start local dev server
make dev

Almacenamiento Serverless Opcional (libSQL / Turso y Cloud Run)

Friday admite un modelo de ejecución serverless opcional respaldado por libSQL remoto (Turso) o transacciones SQLite locales, ideal para entornos efímeros como Google Cloud Run.

• Límite de Almacenamiento Dual: SQLite transaccional para implementaciones locales de un solo nodo; controlador libSQL remoto para instancias serverless distribuidas con dependencia cero de estado local.
• Puerta de Enlace FastAPI Serverless: gateway.serverless:create_app expone todos los endpoints principales de memoria, hechos, grafo y blueprint con aislamiento por ámbito de proyecto y lecturas autenticadas.
• Manual de Migración y Calificación: Scripts privados de exportación/importación, migraciones de esquema y verificaciones de calificación están documentados en docs/serverless-migration.md.

Nota: El almacenamiento serverless es completamente opcional y no altera la implementación predeterminada de Docker Compose ni el enrutamiento del cliente.

Contribuciones

Revisa CONTRIBUTING.md para las pautas de solicitudes de extracción, convenciones de commits y estándares arquitectónicos.

Contribuyentes

Shobhit Singh Creador y Mantenedor

Dan Strong Contribuyente de Código Abierto

Licencia

Friday está licenciado bajo la Licencia MIT.