convez.ai
MCP ServerAutomaçãoAvançado
PrecipAI

AGI Memory - Plataforma de Memória Longa para Agentes IA

PrecipAI/AGI-Memory

Memória longa e conhecimento governado para agentes IA via MCP

Ver no GitHub
BomPluginScore · de 0 a 100

MCP server que fornece memória de longo prazo governada e evolução de conhecimento orientada a grafos para agentes IA. Combina armazenamento de histórico, recuperação vetorial e ingestão de conhecimento em um sistema de engenharia único, com regras de acesso, auditoria e governance evolutiva.

Instalação

$npx convez-ai PrecipAI/AGI-Memory

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
8
Forks
0
Acompanhando
1
Saúde
62%
Último commit
há 4 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Adicionar memória persistente a agentes de código (Claude Code, Codex)
  • Conectar plataforma de conhecimento privada a hosts de agentes via MCP
  • Enforçar regras pré-execução para operações críticas com auditoria
  • Construir camada de memória que evolui por governance, não por acúmulo

Veredito

Solução enterprise-grade para memória de agentes IA com foco em governance e evolução controlada do conhecimento. Ideal para times que querem tratar memória de agentes como sistema de engenharia, não como patch no prompt; requer infraestrutura Node.js >= 20 e conhecimento de MCP.

README

A tradução para o português deste README ainda está na fila.

Agent Memory Knowledge Platform

Unified long-term memory and knowledge platform for AI agents, with MCP access, memory governance, rule gating, and graph-oriented knowledge evolution.

Repository Gates Node.js >= 20 MCP Status

Built for teams that want long-term agent memory to behave like an engineering system instead of a prompt-side workaround.

Highlights

  • Unified long-term memory, knowledge, rule, and skill platform
  • MCP integration for agent hosts such as Codex and Claude Code
  • Governance-oriented knowledge evolution instead of append-only storage
  • Rule-gated high-risk operations with auditability
  • Markdown-first ingestion and graph-first knowledge synthesis

Typical use cases

  • Add governed long-term memory to coding agents such as Codex and Claude Code
  • Connect a private knowledge platform to agent hosts through MCP
  • Enforce pre-execution rules for risky operations such as config mutation or governance approval
  • Build a memory and knowledge layer that can evolve through governance instead of accumulating raw artifacts
  • Compare retrieval, graph expansion, and structured navigation strategies on the same corpus

Why this project

Most agent memory systems stop at one of three incomplete states:

  • chat history storage
  • vector-only retrieval
  • isolated knowledge/document ingestion

This project combines them into one engineering system:

  • long-term memory for agents
  • governed knowledge ingestion and evolution
  • host-agnostic MCP access for Codex, Claude Code, OpenCode, OpenClaw, and custom agents
  • rule-aware context assembly before execution
  • graph-first governance for cross-source knowledge linking and consolidation

The goal is not to build a larger document pile. The goal is to build a system that becomes cleaner, more reusable, and more reliable as knowledge accumulates.

What it includes

  • memory-service: the main backend for memory, rule, skill, governance, and retrieval contracts
  • memory-mcp-server: the MCP adapter that exposes the system to agent hosts over stdio
  • knowledge-ops-console: the review and inspection UI for ingested knowledge and governance output
  • embedding-service: vector backend integration entrypoint
  • db and libs/*: contracts, repositories, migrations, and shared system modules
  • tests and scripts: verification, smoke tests, evaluation scripts, and dataset tooling

Core capabilities

  • Long-term memory with factual, procedural, resident, and rule-oriented layers
  • MCP tool surface for memory_health, memory_retrieve_context, memory_ingest_candidate, memory_query_layer, memory_run_governance, and rule_gate_check
  • Explicit fingerprint_status contract for safe procedural retrieval
  • Host integration templates and install flow for Codex and Claude Code
  • Rule-gated high-risk operations with audit records
  • Markdown-first knowledge ingestion
  • Governance-oriented knowledge evolution instead of append-only storage
  • Cross-source relation discovery and synthesized knowledge generation
  • Knowledge Ops Console for inspection and debugging

Architecture

At a high level, the system is split into four planes:

  1. Ingestion plane External knowledge, task outputs, rules, and reusable skills enter through constrained write paths.
  2. Governance plane The system deduplicates, aligns, upgrades, rejects, or synthesizes knowledge instead of blindly accumulating artifacts.
  3. Retrieval and assembly plane Context is assembled by layer, with rule constraints and memory contracts applied before work execution.
  4. Host integration plane MCP adapters expose the platform to agent hosts without coupling the core system to any one client runtime.

Repository layout

.
├── db/                          # schema and migrations
├── docs/                        # specs and design documents
├── libs/                        # shared contracts and repositories
├── scripts/                     # verification, packaging, evaluation, and tooling
├── services/
│   ├── memory-service/          # backend API and governance core
│   ├── memory-mcp-server/       # MCP server and host install flow
│   ├── knowledge-ops-console/   # inspection UI
│   └── embedding-service/       # vector backend integration entrypoint
├── tests/                       # integration and benchmark coverage
└── SPEC-SuperAgentSystem-knowledge-platform.md

Getting started

Prerequisites

  • Node.js >= 20
  • PostgreSQL available for the repo workflow
  • npm dependencies installed

Install

npm install

Short verification path

If you only want to verify the memory and MCP path first:

npm run verify:mcp-cli
npm run verify:mcp-client-smoke
npm run verify:mcp

Build

npm run build

Start the main services

npm run start:memory-service
npm run start:memory-mcp
npm run start:knowledge-ops-console

MCP quickstart

Initialize local MCP config:

npm run memory-mcp:init

Run health checks:

npm run memory-mcp:doctor

Start the MCP server:

npm run memory-mcp:start

The generated .memory-mcp/clients directory contains host-specific config templates for:

  • Codex
  • Claude Code
  • Claude Desktop
  • OpenCode
  • OpenClaw
  • generic MCP clients

For package-level details, see services/memory-mcp-server/README.md.

Verification

The repo includes end-to-end MCP and knowledge-platform verification scripts.

npm run verify:mcp-cli
npm run verify:mcp-client-smoke
npm run verify:mcp

Additional verification coverage:

  • npm run verify:memory
  • npm run verify:knowledge
  • npm run verify:knowledge-ops-console
  • npm run verify:mcp-pack
  • npm run verify:governance-complete

Current status

This repository is an engineering-stage platform, not a consumer-ready product.

Current characteristics:

  • MCP integration for agent hosts is working
  • single-tenant validation mode is the current operational baseline
  • external memory-service dependency remains required
  • governance and graph-oriented knowledge evolution are active design priorities
  • host hot-plug integration exists, but broader host packaging/distribution is still evolving

Design principles

  • Product-unified, engineering-layered memory and knowledge system
  • Graph-first governance instead of document-first accumulation
  • Markdown as the standard canonical knowledge source
  • Retrieval contracts must be explicit, not implied
  • High-risk changes must pass rule gates
  • Governance must improve knowledge quality, not just knowledge volume

Documentation

Roadmap

  • Strengthen graph-based governance and cross-source relation synthesis
  • Expand evaluation coverage for multihop retrieval and structured navigation
  • Improve host integration packaging for more agent runtimes
  • Replace temporary/vector baselines with production-grade retrieval backends where needed
  • Continue separating stable long-term knowledge from intermediate governance artifacts

License

This repository is currently distributed under a private internal-use license. See LICENSE.

Ver o original no GitHub

Bom para

Relacionados