convez.ai
MCP ServerDados & AnalyticsIntermediário
rush-db

RushDB

rush-db/rushdb

Grafo + vetor + memória para agentes IA em uma API, sem schema

Ver no GitHub
BomPluginScore · de 0 a 100

Camada de memória em grafo + vetor para agentes de IA que unifica Redis, vector stores e Neo4j em uma única API. Ingere JSON sem esquema, auto-detecta relacionamentos e oferece busca semântica e traversal de grafo nativamente, eliminando pipelines de embedding e sincronização manual.

Instalação

$npx convez-ai rush-db/rushdb

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
375
Forks
35
Acompanhando
2
Saúde
62%
Último commit
há 1 dia
Versão
v3.0.12
Issues abertas
28
Contribuidores
4

Casos de uso

  • Memória persistente para agentes IA autônomos
  • Busca semântica com contexto relacional em um tiro
  • Ingestão rápida de dados heterogêneos sem migrations

Veredito

RushDB reduz significativamente a complexidade de stacks de memória para agentes, consolidando três bancos em um. Ideal para quem quer movimentação rápida sem overhead de schema e orquestração.

README

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

RushDB Logo

RushDB

The memory layer for AI agents and apps.

Push any JSON. Your agent gets graph relationships, semantic search, and a live queryable schema — automatically. No pipeline. No separate stores. No schema planning.

GitHub Stars Follow on X NPM Version PyPI Version License CI

🌐 Website • 📖 Documentation • ☁️ Cloud • 🔍 Examples


The problem

Your agent needs memory. The standard answer is three databases: Redis for key-value, a vector store for semantic search, a graph DB for relationships — plus glue code to keep them in sync.

RushDB replaces all three. Push JSON once. Query it with graph traversal, semantic search, or both — in one call.

Without RushDBWith RushDB
Redis + Pinecone + Neo4j + glue codeOne API
Design schema → write migrations → repeatPush any shape, no schema required
Separate embedding pipelineManaged embeddings, server-side
Hand-craft relationship edgesAuto-detected from your data structure

Quick start

Two paths depending on your setup:

Cloud path

npm install @rushdb/javascript-sdk
# or
pip install rushdb

Store and recall agent memory

import RushDB from '@rushdb/javascript-sdk'

const db = new RushDB('RUSHDB_API_KEY')

// One-time: tell RushDB to auto-embed 'output' on every write
await db.ai.indexes.create({ label: 'MEMORY', propertyName: 'output' })

// Store an agent action — no embedder, no vectors array
await db.records.create({
  label: 'MEMORY',
  data: {
    agent_id: 'agent-42',
    session_id: 'sess-001',
    action: 'summarized',
    topic: 'Q4 results',
    output: summaryText
  }
})

// Recall by meaning — graph filter + semantic search in one call
const memories = await db.ai.search({
  labels: ['MEMORY'],
  propertyName: 'output',
  query: 'what did we decide about Q4?',
  where: { agent_id: 'agent-42' },
  limit: 10
})
from rushdb import RushDB

db = RushDB('RUSHDB_API_KEY')

# Store — graph links sessions, actions, and context automatically
db.records.create(
    label='MEMORY',
    data={
        'agent_id': 'agent-42',
        'action': 'summarized',
        'topic': 'Q4 results',
        'output': summary_text,
    },
)

# Recall — traverse relationships and filter by meaning
results = db.records.find({
    'labels': ['MEMORY'],
    'where': {
        'agent_id': 'agent-42',
        'topic': {'$contains': 'Q4'},
    },
    'limit': 10,
})
// Push nested JSON — RushDB normalizes it into a graph, no schema needed
await db.records.importJson({
  label: 'COMPANY',
  payload: {
    name: 'Acme Corp',
    DEPARTMENT: [
      {
        name: 'Engineering',
        EMPLOYEE: [
          {
            name: 'Alice',
            role: 'Staff Engineer'
          }
        ]
      }
    ]
  }
})

// Traverse the auto-created relationships
const engineers = await db.records.find({
  labels: ['EMPLOYEE'],
  where: {
    role: { $contains: 'Engineer' },
    DEPARTMENT: { COMPANY: { name: 'Acme Corp' } }
  }
})

Connect to Claude, Cursor, or any MCP client

RushDB ships an MCP server. Your agent gets persistent, structured memory — out of the box.

{
  "mcpServers": {
    "rushdb": {
      "command": "npx",
      "args": ["@rushdb/mcp-server"],
      "env": {
        "RUSHDB_API_KEY": "your-api-key-here"
      }
    }
  }
}

Place this in your Claude Desktop, Cursor, or Windsurf MCP config. The agent can now create records, search by meaning, traverse relationships, and introspect the schema — all via natural language.


What's in the box

CapabilityWhat it means
Managed embeddingsIndex any string property once — every write is auto-embedded server-side
Graph + vector in one querySemantic similarity and relationship traversal compose in a single call
Zero schemaPush any JSON shape. RushDB infers types, creates properties, links records
ACID transactionsConcurrent agents don't corrupt shared memory. Neo4j under the hood
Self-describing graphAgents enumerate labels, properties, and value ranges to orient themselves
MCP-nativeFull MCP server with discovery-first query prompt built in
Agent SkillsInstallable @rushdb/skills package — teach any skills-compatible agent to query, model, and remember with RushDB in one command
Unified query APIOne JSON shape for graph, vector, aggregation, and introspection
Self-host or cloudDocker + your Neo4j, or managed cloud. Full data ownership

Use cases

Use caseWhat RushDB replacesKey API
Agent memoryRedis + vector store + graph DBdb.ai.search({ query, where: { agent_id } })
RAG with contextFlat vector storedb.records.find({ where, labels }) + relationship traversal
Schema-free appsPostgres + migrations + ETLdb.records.importJson(nestedJson)
Connected data productsMultiple joined servicesdb.records.find({ labels, where: { SOME_LABEL: { ... } } })

Self-hosting

Self-host path — run RushDB on your own infrastructure. Requires Neo4j 2026.01.4+ with APOC plugin.

# docker-compose.yml
version: '3.8'
services:
  rushdb:
    image: rushdb/platform
    ports:
      - '3000:3000'
    environment:
      - NEO4J_URL=neo4j+s://your-instance.neo4j.io
      - NEO4J_USERNAME=neo4j
      - NEO4J_PASSWORD=password
      - RUSHDB_AES_256_ENCRYPTION_KEY=32-char-key-here
      - RUSHDB_LOGIN=admin
      - RUSHDB_PASSWORD=secure-password
NameDescriptionRequiredDefault
NEO4J_URLNeo4j connection URLyes—
NEO4J_USERNAMENeo4j usernameyesneo4j
NEO4J_PASSWORDNeo4j passwordyes—
RUSHDB_AES_256_ENCRYPTION_KEY32-char key for API token encryptionyes (prod)—
RUSHDB_PORTHTTP portno3000
RUSHDB_LOGINAdmin loginnoadmin
RUSHDB_PASSWORDAdmin passwordnopassword
version: '3.8'
services:
  rushdb:
    image: rushdb/platform
    depends_on:
      neo4j:
        condition: service_healthy
    ports:
      - '3000:3000'
    environment:
      - NEO4J_URL=bolt://neo4j
      - NEO4J_USERNAME=neo4j
      - NEO4J_PASSWORD=password
  neo4j:
    image: neo4j:2026.01.4
    healthcheck:
      test: ['CMD-SHELL', 'wget --no-verbose --tries=1 --spider localhost:7474 || exit 1']
      interval: 5s
      retries: 30
      start_period: 10s
    ports:
      - '7474:7474'
      - '7687:7687'
    environment:
      - NEO4J_ACCEPT_LICENSE_AGREEMENT=yes
      - NEO4J_AUTH=neo4j/password
    volumes:
      - ./neo4j-plugins:/var/lib/neo4j/plugins
# Manage users via CLI
rushdb create-user admin@example.com securepassword123
rushdb update-password admin@example.com newsecurepassword456

RushDB uses a Labeled Meta Property Graph (LMPG) model. Properties are elevated to first-class graph nodes ("HyperProperties") — not just key-value pairs attached to records.

This means:

  • Auto-detected relationships — records sharing properties get linked without hand-crafting edges
  • Schema introspection — agents can enumerate labels, property types, value ranges, and relationship topology in one query
  • Soft constraints — type cohesion scoring, cardinality tracking, and vector dimension enforcement without rigid upfront schemas
  • Unified query surface — the same filter expression works across records, labels, properties, and relationships

One SearchQuery retrieves multiple perspectives simultaneously (records + property stats + aggregations), avoiding the N+1 inspection pattern common in separate-system architectures.

Read the full LMPG architecture post →


Documentation

TopicLink
Quick Tutorialhttps://docs.rushdb.com/get-started/quick-tutorial
Vector / Semantic Searchhttps://docs.rushdb.com/concepts/search/where#vector-operators
Filtering & Traversalhttps://docs.rushdb.com/concepts/search/where
Grouping & Aggregationshttps://docs.rushdb.com/concepts/search/group-by
TypeScript SDKhttps://docs.rushdb.com/typescript-sdk/introduction
Python SDKhttps://docs.rushdb.com/python-sdk/introduction
REST APIhttps://docs.rushdb.com/rest-api/introduction
MCP Serverpackages/mcp-server/README.md
Agent Skillspackages/skills/README.md

When not to use RushDB

  • You need sub-millisecond latency at very high write throughput — RushDB is built on Neo4j, which prioritises consistency and query expressiveness over raw write speed.
  • You only need flat key-value storage with no relationships or semantic search — a simpler store will be lighter.
  • You need a rigid relational schema enforced at the database level — RushDB is deliberately schema-free.

Contributing

git clone https://github.com/rush-db/rushdb.git
cd rushdb
pnpm install
pnpm test

See CONTRIBUTING.md for full guidelines. Issues and PRs welcome.


License

PathLicense
platform/coreElastic License 2.0
platform/dashboardElastic License 2.0
docsApache 2.0
websiteApache 2.0
packages/javascript-sdkApache 2.0
packages/mcp-serverApache 2.0

Need something not supported yet? Open an issue — design discussions are welcome.

Ver o original no GitHub

Bom para

Relacionados