Hipocampo MCP

Busca en el Hipocampo (memoria dual con SSC / BIRE v3.6). Es solo lectura — no modifica datos, no tiene efectos secundarios. Sin límites de tasa (rate limits). Realiza búsqueda semántica + léxica híbrida en las bases de datos de memoria del usuario, incluyendo memoria técnica (*memoria_vectorial*) y de perfil (*memory_items*). Si se proporciona session_id, filtra solo memorias de esa sesión. Para búsquedas rápidas cuando el nombre corto sea preferido, usar quick_hipocampo_search (alias idéntico). Esta herramienta es la versión completa con nombre descriptivo. Args: query: Texto de búsqueda en lenguaje natural. Máximo 500 caracteres. Ejemplos: "proyecto contable", "perro", "planta medicinal", "API REST en Python", "gusta del té". session_id: Opcional. Filtra resultados a una sesión específica. Returns: Resultados formateados del BIRE como texto plano. Incluye: contenido encontrado, scores de relevancia, y metadatos. Si no hay coincidencias, indica búsqueda exitosa pero sin resultados.

{
  "type": "object",
  "properties": {
    "query": {
      "title": "Query",
      "type": "string"
    },
    "session_id": {
      "default": "",
      "title": "Session Id",
      "type": "string"
    }
  },
  "required": [
    "query"
  ],
  "title": "search_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "search_hipocampoOutput"
}

Búsqueda rápida en el Hipocampo (alias corto de search_hipocampo). Es solo lectura — no modifica datos, no tiene efectos secundarios. Comportamiento y salida idénticos a search_hipocampo. Útil cuando el cliente MCP prefiera nombres de herramienta más cortos. Para nombre descriptivo, usar search_hipocampo. Args: query: Texto de búsqueda en lenguaje natural. Igual que search_hipocampo. Ej: "API REST en Python", "presupuesto". session_id: Opcional. Filtra resultados a una sesión específica. Returns: Mismo formato que search_hipocampo: resultados como texto plano con scores de relevancia y metadatos.

{
  "type": "object",
  "properties": {
    "query": {
      "title": "Query",
      "type": "string"
    },
    "session_id": {
      "default": "",
      "title": "Session Id",
      "type": "string"
    }
  },
  "required": [
    "query"
  ],
  "title": "quick_hipocampo_searchArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "quick_hipocampo_searchOutput"
}

Compress retrieved memories using a hybrid approach (extractive + LLM). First searches Hipocampo (SSC v1.0), then compresses the top-k results: - method="extractive": sentence-level keyword relevance (fast, no API cost) - method="llm": summarization via NVIDIA NIM (highest quality, API cost) - method="hybrid" (default): uses LLM for technical/code content, extractive for generic text Use this tool BEFORE sending context to another LLM to reduce prompt size while preserving critical information. Args: query: Natural language search query. k: Number of memories to retrieve (default 5, max 20). method: Compression method: "hybrid" (default), "extractive", or "llm". target_token: Target token count (-1 = auto, based on content). include_metadata: Include per-memory details in output. budget_ratio: Scale factor for auto-estimated tokens (default 1.0). Returns: Compressed context as plain text with compression statistics. Includes: compressed text, original/compressed char counts, ratio, latency.

{
  "type": "object",
  "properties": {
    "query": {
      "title": "Query",
      "type": "string"
    },
    "k": {
      "default": 5,
      "title": "K",
      "type": "integer"
    },
    "method": {
      "default": "hybrid",
      "title": "Method",
      "type": "string"
    },
    "target_token": {
      "default": -1,
      "title": "Target Token",
      "type": "integer"
    },
    "include_metadata": {
      "default": false,
      "title": "Include Metadata",
      "type": "boolean"
    },
    "budget_ratio": {
      "default": 1,
      "title": "Budget Ratio",
      "type": "number"
    }
  },
  "required": [
    "query"
  ],
  "title": "compress_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "compress_hipocampoOutput"
}

Guarda un recuerdo en el Hipocampo (memoria_vectorial). INSERT inmediato y NO bloqueante: el embedding se genera en background (_finalize_save_bg) junto con dedup semántico, auto-link y auditoría de contradicciones. Hasta que el embedding se backfillea (~segundos), la memoria queda en tier WARM (embedding=NULL) y es recuperable por texto. Si ya existe un recuerdo casi idéntico (trigram), se advierte y se omite el guardado a menos que force=True. El dedup semántico (>0.9) corre en background y solo loguea — no bloquea. Args: content: Texto del recuerdo a guardar. memory_type: Tipo de memoria. Valores comunes: "event" (evento/experiencia), "decision" (decisión tomada), "profile" (dato personal). Por defecto: "event". code: Código o etiqueta corta para agrupar recuerdos (opcional). Ej: "documentacion", "bugfix", "feature", "setup". categories: Lista de categorías (opcional). Ej: ["python", "mcp", "infraestructura"]. session_id: Opcional. Identificador de sesión para aislar memorias. force: Si True, guarda incluso si existe un recuerdo muy similar. auto_link: Si True, busca recuerdos semánticamente similares (>0.75) y crea enlaces "similar" automáticamente. nivel: Nivel de memoria jerárquica: "episodica" (default) — detalle completo, comprimible, "semantica" — conocimiento consolidado, protegido, "automatica" — regla permanente, nunca se comprime. critico: Si True, la memoria NUNCA se olvida ni se archiva. Protección de por vida independiente del nivel. Returns: Confirmación con el ID asignado.

{
  "type": "object",
  "properties": {
    "content": {
      "title": "Content",
      "type": "string"
    },
    "memory_type": {
      "default": "event",
      "title": "Memory Type",
      "type": "string"
    },
    "code": {
      "default": "",
      "title": "Code",
      "type": "string"
    },
    "categories": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Categories"
    },
    "session_id": {
      "default": "",
      "title": "Session Id",
      "type": "string"
    },
    "force": {
      "default": false,
      "title": "Force",
      "type": "boolean"
    },
    "auto_link": {
      "default": false,
      "title": "Auto Link",
      "type": "boolean"
    },
    "nivel": {
      "default": "episodica",
      "title": "Nivel",
      "type": "string"
    },
    "critico": {
      "default": false,
      "title": "Critico",
      "type": "boolean"
    }
  },
  "required": [
    "content"
  ],
  "title": "save_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "save_hipocampoOutput"
}

Detecta contradicciones semánticas de una memoria existente. Usa negation-probe embedding: embedea "AFIRMACIÓN: {contenido} — ¿Esto es FALSO según: ..." y compara con el embedding original. Si la distancia de la sonda de negación es MENOR que la del contenido original → señal de contradicción. Args: memory_id: ID numérico de la memoria en memoria_vectorial.

{
  "type": "object",
  "properties": {
    "memory_id": {
      "title": "Memory Id",
      "type": "integer"
    }
  },
  "required": [
    "memory_id"
  ],
  "title": "contradicciones_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "contradicciones_hipocampoOutput"
}

Guarda un dato de perfil personal en Hipocampo (memory_items). A diferencia de save_hipocampo (que guarda en memoria_vectorial técnica), esta herramienta guarda en memory_items, que está diseñado para datos personales: gustos, familia, preferencias, datos biográficos. Args: summary: Texto corto con el dato personal. Ej: "Al usuario le gusta el té de hierbas". extra: Información adicional en texto plano (opcional). categories: Categorías (opcional). Ej: ["personal_info", "gustos"]. Returns: Confirmación con el ID asignado.

{
  "type": "object",
  "properties": {
    "summary": {
      "title": "Summary",
      "type": "string"
    },
    "extra": {
      "default": "",
      "title": "Extra",
      "type": "string"
    },
    "categories": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Categories"
    }
  },
  "required": [
    "summary"
  ],
  "title": "profile_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "profile_hipocampoOutput"
}

Actualiza un recuerdo existente en el Hipocampo (memoria_vectorial). Si se proporciona content, se regenera el embedding automáticamente. Los campos no proporcionados no se modifican. Args: id: ID numérico del recuerdo a actualizar. content: Nuevo texto del recuerdo (opcional). Si se provee, se regenera el embedding. memory_type: Nuevo tipo de memoria (opcional). Ej: "event", "decision". code: Código o etiqueta corta (opcional). categories: Nueva lista de categorías (opcional). Returns: Confirmación de la actualización.

{
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "integer"
    },
    "content": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Content"
    },
    "memory_type": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Memory Type"
    },
    "code": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Code"
    },
    "categories": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Categories"
    }
  },
  "required": [
    "id"
  ],
  "title": "update_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "update_hipocampoOutput"
}

Cambia el nivel jerárquico de un recuerdo. Niveles: - "episodica" — detalle completo, comprimible por checkpoint - "semantica" — conocimiento consolidado, protegido de compresión - "automatica" — regla permanente, nunca se comprime/checkpointea Args: id: ID del recuerdo. nivel: Nuevo nivel: "episodica", "semantica", o "automatica". Returns: Confirmación del cambio.

{
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "integer"
    },
    "nivel": {
      "title": "Nivel",
      "type": "string"
    }
  },
  "required": [
    "id",
    "nivel"
  ],
  "title": "set_nivel_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "set_nivel_hipocampoOutput"
}

Consolidación jerárquica: migra memorias episódicas antiguas a semánticas. Busca recuerdos con nivel 'episodica' más antiguos que min_age_days y los promueve a 'semantica', opcionalmente comprimiendo su contenido. Args: min_age_days: Edad mínima en días para consolidar (default 7). dry_run: Si True, solo muestra qué se consolidaría. Returns: Reporte de la consolidación.

{
  "type": "object",
  "properties": {
    "min_age_days": {
      "default": 7,
      "title": "Min Age Days",
      "type": "integer"
    },
    "dry_run": {
      "default": true,
      "title": "Dry Run",
      "type": "boolean"
    }
  },
  "title": "consolidate_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "consolidate_hipocampoOutput"
}

Revisa reglas 'automatica' sin revisión en los últimos N días. Las reglas automatica son permanentes por diseño, pero pueden degradarse a 'semantica' si no han sido útiles (review_count=0) después de max_age_days. Con dry_run=True solo lista las reglas candidatas a degradación. Con dry_run=False las degrada a 'semantica' (no se borran, solo pierden inmunidad de compresión). Args: max_age_days: Edad máxima sin revisión antes de considerar degradación (default 30). dry_run: Si True, solo muestra qué se degradaría. Returns: Reporte de reglas encontradas.

{
  "type": "object",
  "properties": {
    "max_age_days": {
      "default": 30,
      "title": "Max Age Days",
      "type": "integer"
    },
    "dry_run": {
      "default": true,
      "title": "Dry Run",
      "type": "boolean"
    }
  },
  "title": "review_automaticaArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "review_automaticaOutput"
}

Valida una regla inmunológica (Nivel 4). Analiza una regla 'automatica' marcada como REGLA INMUNOLÓGICA: 1. Verifica snapshots pre-cambio vinculados en memory_links 2. Detecta reglas contradictorias sobre el mismo archivo/proyecto 3. Reporta reglas huérfanas (>30d sin enlaces entrantes) Args: rule_id: ID de la regla inmunológica a validar. Returns: Reporte de validación con recomendaciones.

{
  "type": "object",
  "properties": {
    "rule_id": {
      "title": "Rule Id",
      "type": "integer"
    }
  },
  "required": [
    "rule_id"
  ],
  "title": "validate_immune_ruleArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "validate_immune_ruleOutput"
}

Elimina un recuerdo del Hipocampo (memoria_vectorial) por su ID. Esta operación es irreversible. Una vez eliminado, el recuerdo no podrá recuperarse ni aparecerá en búsquedas futuras. Args: id: ID numérico del recuerdo a eliminar. Returns: Confirmación de eliminación.

{
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "integer"
    }
  },
  "required": [
    "id"
  ],
  "title": "delete_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "delete_hipocampoOutput"
}

Ejecuta un health check completo del sistema Hipocampo. Verifica: PostgreSQL, NVIDIA API, tablas, espacio en disco, extensiones. Returns: Reporte formateado del estado del sistema.

{
  "type": "object",
  "properties": {},
  "title": "hipocampo_healthArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "hipocampo_healthOutput"
}

Intenta reparar automáticamente problemas detectados en el sistema. Reparaciones posibles: - Reiniciar PostgreSQL si está caído - Crear tablas faltantes desde esquema.sql - Verificar/configurar NVIDIA_API_KEY Returns: Reporte de reparaciones ejecutadas.

{
  "type": "object",
  "properties": {},
  "title": "hipocampo_auto_repairArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "hipocampo_auto_repairOutput"
}

Muestra estadísticas de rendimiento del sistema Hipocampo. Analiza latencia de queries, métodos usados, scores promedios y da recomendaciones de optimización. Returns: Reporte de métricas y recomendaciones.

{
  "type": "object",
  "properties": {},
  "title": "hipocampo_statsArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "hipocampo_statsOutput"
}

Ajusta automáticamente los thresholds y pesos del SSC basado en las métricas de rendimiento acumuladas. Es destructivo: modifica los thresholds y pesos de forma irreversible. Sin embargo, es idempotente: ejecutarlo múltiples veces converge al mismo resultado. Usar con precaución. Para solo ver estadísticas sin modificar nada, usar hipocampo_stats (solo lectura). Para ejecutar el ciclo completo de mantenimiento (que incluye tune como paso 5), usar hipocampo_maintenance. Recomendado ejecutar solo después de acumular suficientes métricas (al menos 100 consultas registradas). No usar si el sistema funciona correctamente sin degradación. Returns: Reporte de ajustes aplicados (nuevos thresholds y pesos).

{
  "type": "object",
  "properties": {},
  "title": "hipocampo_tuneArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "hipocampo_tuneOutput"
}

Detecta y opcionalmente fusiona duplicados en las tablas de memoria. Con merge=False (default) es solo lectura — seguro de ejecutar, no modifica datos. Con merge=True es destructivo: consolida filas duplicadas en una sola, operación irreversible. Usar con precaución. Ejecutar primero sin merge para previsualizar. ¿Qué es un duplicado? Dos registros con alta similitud semántica (embedding + texto), por encima del umbral configurable (default 0.95). El reporte incluye: cantidad de duplicados encontrados, IDs afectados y resumen de fusión si se ejecutó merge. Para ejecutar dedup como parte del ciclo completo de mantenimiento, usar hipocampo_maintenance (paso 2 del ciclo). Esta herramienta es para uso puntual o previsualización antes del merge. Args: merge: Si es True, fusiona los duplicados encontrados (irreversible). Si es False (default), solo muestra análisis (seguro). Returns: Reporte de duplicados encontrados o fusionados.

{
  "type": "object",
  "properties": {
    "merge": {
      "default": false,
      "title": "Merge",
      "type": "boolean"
    }
  },
  "title": "hipocampo_dedupArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "hipocampo_dedupOutput"
}

Comprime memorias antiguas usando checkpointing logarítmico. Con dry_run=True (default) es solo lectura — seguro, no modifica datos. Con dry_run=False es destructivo: comprime memorias antiguas de forma irreversible (las originales se eliminan tras comprimir). Idempotente: ejecutar múltiples veces no daña datos. Para ejecutar checkpoint como parte del ciclo completo de mantenimiento, usar hipocampo_maintenance (paso 3 del ciclo). Esta herramienta es para ejecución puntual o previsualización. Recomendado ejecutar periódicamente (semanal o mensual) para mantener el rendimiento del sistema. Args: dry_run: Si es True (default), solo muestra qué se comprimiría. Si es False, ejecuta la compresión (irreversible). Returns: Reporte del checkpointing ejecutado o simulado. Incluye: cantidad de registros comprimidos, espacio liberado.

{
  "type": "object",
  "properties": {
    "dry_run": {
      "default": true,
      "title": "Dry Run",
      "type": "boolean"
    }
  },
  "title": "hipocampo_checkpointArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "hipocampo_checkpointOutput"
}

Revierte un checkpoint usando el snapshot guardado previamente. Busca el snapshot por ID y verifica qué IDs originales fueron comprimidos. Si los originales aún existen, reporta que no se necesita rollback. Si fueron eliminados, intenta restaurarlos. Args: snapshot_id: ID del snapshot [CHECKPOINT SNAPSHOT] guardado. Returns: Reporte de la operación de rollback.

{
  "type": "object",
  "properties": {
    "snapshot_id": {
      "title": "Snapshot Id",
      "type": "integer"
    }
  },
  "required": [
    "snapshot_id"
  ],
  "title": "rollback_checkpointArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "rollback_checkpointOutput"
}

Ejecuta el ciclo completo de mantenimiento: 1. Health check → auto-repair si es necesario 2. Dedup → fusiona duplicados 3. Checkpoint → comprime memorias antiguas 4. Purge → limpia access logs antiguos (>30d) 5. Tune → ajusta thresholds según métricas Nota: hipocampo_budget y decay_hipocampo se ejecutan manualmente o via cron separado (son destructivos y requieren dry_run previo). Returns: Reporte consolidado del mantenimiento.

{
  "type": "object",
  "properties": {},
  "title": "hipocampo_maintenanceArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "hipocampo_maintenanceOutput"
}

Registra un webhook que se dispara cuando se crea/modifica/elimina un recuerdo cuyo contenido o metadatos contengan el patrón dado. Args: pattern: Texto a buscar en contenido o metadatos del recuerdo. webhook_url: URL que recibirá un POST con event, id, content, metadatos. Returns: Confirmación con ID del watch creado.

{
  "type": "object",
  "properties": {
    "pattern": {
      "title": "Pattern",
      "type": "string"
    },
    "webhook_url": {
      "title": "Webhook Url",
      "type": "string"
    }
  },
  "required": [
    "pattern",
    "webhook_url"
  ],
  "title": "watch_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "watch_hipocampoOutput"
}

Elimina un webhook registrado por su ID. Args: id: ID del watch a eliminar. Returns: Confirmación de eliminación.

{
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "integer"
    }
  },
  "required": [
    "id"
  ],
  "title": "unwatch_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "unwatch_hipocampoOutput"
}

Lista todos los webhooks registrados. Returns: Lista de watches con ID, patrón y URL.

{
  "type": "object",
  "properties": {},
  "title": "list_watchesArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "list_watchesOutput"
}

Pre-load context for a project or workspace. Extracts relevant memories from the project path and returns them as a compressed summary. Use this when starting work on a known project to restore working context. Args: project_path: Absolute path to the project or workspace. If empty, uses current working directory. k: Number of relevant memories to retrieve (default 8, max 20). Returns: Compressed context summary with project-relevant memories.

{
  "type": "object",
  "properties": {
    "project_path": {
      "default": "",
      "title": "Project Path",
      "type": "string"
    },
    "k": {
      "default": 8,
      "title": "K",
      "type": "integer"
    }
  },
  "title": "preload_contextArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "preload_contextOutput"
}

Crea un enlace entre dos recuerdos en el grafo de memoria. Args: source_id: ID del recuerdo origen (numérico: memoria_vectorial; string: memory_items). target_id: ID del recuerdo destino. relation_type: Tipo de relación. Valores comunes: "related" (default), "follow_up", "part_of", "references", "similar", "chain", "validates", "contradicts". weight: Peso de la relación (0.0 a 1.0, default 1.0). Returns: Confirmación del enlace creado.

{
  "type": "object",
  "properties": {
    "source_id": {
      "title": "Source Id",
      "type": "integer"
    },
    "target_id": {
      "title": "Target Id",
      "type": "integer"
    },
    "relation_type": {
      "default": "related",
      "title": "Relation Type",
      "type": "string"
    },
    "weight": {
      "default": 1,
      "title": "Weight",
      "type": "number"
    }
  },
  "required": [
    "source_id",
    "target_id"
  ],
  "title": "link_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "link_hipocampoOutput"
}

Elimina un enlace del grafo de memoria. Args: id: ID del enlace a eliminar (si se conoce). source_id: Si no se provee id, elimina por source+target+type. target_id: ID destino (requerido si no hay id). relation_type: Tipo de relación (opcional si no hay id). Returns: Confirmación de eliminación.

{
  "type": "object",
  "properties": {
    "id": {
      "default": 0,
      "title": "Id",
      "type": "integer"
    },
    "source_id": {
      "default": 0,
      "title": "Source Id",
      "type": "integer"
    },
    "target_id": {
      "default": 0,
      "title": "Target Id",
      "type": "integer"
    },
    "relation_type": {
      "default": "",
      "title": "Relation Type",
      "type": "string"
    }
  },
  "title": "unlink_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "unlink_hipocampoOutput"
}

Explora el grafo de memoria desde un nodo raíz. Args: node_id: ID del recuerdo raíz. Si es 0, lista todos los nodos con enlaces (vista general). depth: Profundidad de exploración (default 2, max 5). max_nodes: Máximo de nodos a mostrar (default 50). Returns: Árbol ASCII del grafo de memoria.

{
  "type": "object",
  "properties": {
    "node_id": {
      "default": 0,
      "title": "Node Id",
      "type": "integer"
    },
    "depth": {
      "default": 2,
      "title": "Depth",
      "type": "integer"
    },
    "max_nodes": {
      "default": 50,
      "title": "Max Nodes",
      "type": "integer"
    }
  },
  "title": "graph_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "graph_hipocampoOutput"
}

Encuentra el camino más corto entre dos recuerdos en el grafo de memoria. Args: from_id: ID del recuerdo origen. to_id: ID del recuerdo destino. max_depth: Profundidad máxima de búsqueda (default 5, max 10). Returns: Camino encontrado como secuencia de nodos.

{
  "type": "object",
  "properties": {
    "from_id": {
      "title": "From Id",
      "type": "integer"
    },
    "to_id": {
      "title": "To Id",
      "type": "integer"
    },
    "max_depth": {
      "default": 5,
      "title": "Max Depth",
      "type": "integer"
    }
  },
  "required": [
    "from_id",
    "to_id"
  ],
  "title": "path_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "path_hipocampoOutput"
}

Indexa archivos de código fuente de un proyecto en Hipocampo (RAG). Escanea archivos PHP, JS, TS, Python, SQL, HTML, CSS, JSON, YAML, los divide en chunks significativos y los guarda como recuerdos con embedding para búsqueda semántica. La segunda corrida solo indexa archivos modificados (por mtime). Args: project_path: Ruta absoluta del proyecto a indexar. Si está vacía, usa el directorio actual. force: Si True, re-indexa todo aunque no haya cambios. Returns: Estadísticas de la indexación.

{
  "type": "object",
  "properties": {
    "project_path": {
      "default": "",
      "title": "Project Path",
      "type": "string"
    },
    "force": {
      "default": false,
      "title": "Force",
      "type": "boolean"
    }
  },
  "title": "index_projectArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "index_projectOutput"
}

Busca código fuente indexado en Hipocampo (RAG). Similar a search_hipocampo pero filtra solo recuerdos de tipo code_snippet y devuelve fragmentos de código real con ubicación de archivo. Args: query: Consulta en lenguaje natural. k: Número de resultados (default 5, max 20). language: Filtrar por lenguaje (php, javascript, python, sql, etc.). Vacío = todos los lenguajes. Returns: Fragmentos de código relevantes con metadatos de archivo.

{
  "type": "object",
  "properties": {
    "query": {
      "title": "Query",
      "type": "string"
    },
    "k": {
      "default": 5,
      "title": "K",
      "type": "integer"
    },
    "language": {
      "default": "",
      "title": "Language",
      "type": "string"
    }
  },
  "required": [
    "query"
  ],
  "title": "search_codeArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "search_codeOutput"
}

Aplica decaimiento temporal a enlaces del grafo Y memorias antiguas. ENLACES: peso exponencial, half-life 90 días. Elimina enlaces < 0.01. MEMORIAS: archiva episodica sin acceso ni protección a memoria_historica. Protecciones (nunca se archivan): - nivel = automatica o semantica - metadatos.critico = true - con enlaces entrantes en memory_links Args: dry_run: True (default) = solo lectura. False = ejecuta cambios. min_age_days: Edad mínima en días para considerar memoria candidata. Returns: Reporte del decaimiento aplicado.

{
  "type": "object",
  "properties": {
    "dry_run": {
      "default": true,
      "title": "Dry Run",
      "type": "boolean"
    },
    "min_age_days": {
      "default": 30,
      "title": "Min Age Days",
      "type": "integer"
    }
  },
  "title": "decay_hipocampoArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "decay_hipocampoOutput"
}

Gestiona el presupuesto de memoria (budget + tiering automático). 3 tiers: - HOT: embedding presente (memoria_vectorial con pgvector) - WARM: embedding=NULL (excluido de HNSW, sigue buscable léxicamente) - COLD: contenido movido a memoria_historica (fuera de búsqueda principal) Protecciones: automatica/semantica/critico/enlazadas → exemptas. Args: dry_run: True (default) = solo análisis. False = ejecuta tiering.

{
  "type": "object",
  "properties": {
    "dry_run": {
      "default": true,
      "title": "Dry Run",
      "type": "boolean"
    }
  },
  "title": "hipocampo_budgetArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "hipocampo_budgetOutput"
}

Restaura una memoria desde memoria_historica a memoria_vectorial. Reconstruye embedding automáticamente. La memoria vuelve al tier HOT. Args: historica_id: ID de la memoria en memoria_historica.

{
  "type": "object",
  "properties": {
    "historica_id": {
      "title": "Historica Id",
      "type": "integer"
    }
  },
  "required": [
    "historica_id"
  ],
  "title": "restaurar_historicaArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "restaurar_historicaOutput"
}

Lista los directorios configurados para auto-reindexación.

{
  "type": "object",
  "properties": {},
  "title": "list_watch_dirsArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "list_watch_dirsOutput"
}

Agrega un directorio al watch list para auto-reindexación.

{
  "type": "object",
  "properties": {
    "path": {
      "title": "Path",
      "type": "string"
    }
  },
  "required": [
    "path"
  ],
  "title": "add_watch_dirArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "add_watch_dirOutput"
}

Elimina un directorio del watch list.

{
  "type": "object",
  "properties": {
    "path": {
      "title": "Path",
      "type": "string"
    }
  },
  "required": [
    "path"
  ],
  "title": "remove_watch_dirArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "remove_watch_dirOutput"
}

Fuerza reindexación inmediata de un directorio (o todos los watch).

{
  "type": "object",
  "properties": {
    "path": {
      "default": "",
      "title": "Path",
      "type": "string"
    }
  },
  "title": "reindex_nowArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "reindex_nowOutput"
}