RushDB MCP Server
OfficialRushDB MCP Server lets MCP-compatible AI clients use RushDB as persistent, structured, graph-traversable memory.
Connect via remote OAuth, local API key, or standalone direct engine over stdio.
Discover schemas: labels, properties, types, ranges, distinct values, relationships, and indexes.
Create/upsert, read, update/replace, delete, bulk-create/delete, and export records as CSV.
Query/filter records with structured SearchQuery, ordering, projections, grouping, and aggregations.
Attach, update, detach, find, and traverse relationships; analyze/approve/ignore relationship patterns.
Search with vector similarity, BM25 keyword search, or hybrid vector+keyword ranking.
Manage embedding indexes (managed/external) and text indexes, write external vectors, and check indexing stats.
Use schema/value discovery, name resolution, query-spec/prompt helpers, and setup instructions.
Run Cloud-only natural-language smartSearch by converting requests to SQL.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@RushDB MCP Server Remember that we chose Clerk over Auth0 for authentication."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
RushDB MCP Server
Connect MCP clients to RushDB, the database for AI.
Connect RushDB to any MCP-compatible AI client and your agent gains persistent, structured memory — semantically searchable and graph-traversable, without managing embeddings or schemas.
Works with ChatGPT, Claude.ai, Claude Desktop, Cursor, Windsurf, Gemini CLI, and any MCP-compatible tool.
Two ways to connect
Remote OAuth (no installation)
For ChatGPT, Claude.ai, and other web-based AI clients — connect directly without installing anything locally:
MCP endpoint: https://mcp.rushdb.com/mcp
Your client redirects to RushDB for OAuth sign-in and receives a scoped token. No API key setup required.
ChatGPT:
Go to Settings → Connectors → Add connector
Enter
https://mcp.rushdb.com/mcpSign in with your RushDB account
Claude.ai:
Go to Settings → Integrations → Add integration
Enter
https://mcp.rushdb.com/mcpAuthorize with your RushDB account
Local (RushDB Cloud API key)
For Claude Desktop, Cursor, Windsurf, VS Code, and other stdio MCP clients:
1. Get an API key at app.rushdb.com
2. Add to your MCP client config:
{
"mcpServers": {
"rushdb": {
"command": "npx",
"args": ["@rushdb/mcp-server"],
"env": {
"RUSHDB_API_KEY": "your-api-key-here"
}
}
}
}Place this in:
Claude Desktop —
~/Library/Application Support/Claude/claude_desktop_config.jsonCursor — MCP settings in the Cursor config panel
Windsurf —
~/.codeium/windsurf/mcp_config.json
3. That's it. The agent now has 43 tools for storing, querying, searching and traversing structured memory.
RUSHDB_API_URLis optional and defaults tohttps://api.rushdb.com/api/v1, the RushDB Cloud API.
Local standalone engine (no Cloud account)
Run the Rust engine, then point a local stdio MCP client at it. This mode calls the public engine protocol directly; it does not use a RushDB Cloud API key, dashboard, or OAuth.
RUSHDB_TOKEN=local-development-token rushdb up --data-dir ./rushdb-data{
"mcpServers": {
"rushdb": {
"command": "npx",
"args": ["-y", "@rushdb/mcp-server"],
"env": {
"RUSHDB_MODE": "direct",
"RUSHDB_ENGINE_URL": "http://127.0.0.1:3000",
"RUSHDB_ENGINE_TOKEN": "local-development-token"
}
}
}
}Direct mode offers every tool whose work the engine does: schema discovery, record reads and writes (with
ordering, projections and aggregations), relationships, labels and properties, bulk import and CSV export, text
indexes and keyword search, and external vector indexes with vector search by a queryVector you supply.
The RushDB Cloud tools are not listed and are refused if called: smartSearch (natural-language search),
the relationship-pattern tools, and anything that needs managed embeddings (a text query for vector search,
managed indexes). The MCP HTTP transport is unavailable in direct mode because its OAuth flow belongs to
RushDB Cloud; run the server through stdio on the same machine as the client.
Related MCP server: Memory Nexus MCP
Compatibility
Package | RushDB 3.x and RushDB Cloud | RushDB 2.x (legacy) |
| 3.x | 2.11.0: |
| 3.x | 2.10.0: |
| 3.x | 2.13.0: |
What an agent can do
After connecting, ask Claude or your agent naturally:
"Remember that we decided to use Clerk for auth, replacing Auth0, on 2026-04-10."
The agent calls createRecord to store a structured memory. Later:
"What auth decisions have we made?"
The agent calls getSchemaMarkdown to learn what is stored, then findRecords, textSearch or vectorSearch.
"Show me everything related to our auth system."
The agent calls findRelationships and findRecords with relationship filters to traverse the graph of connected records.
Available tools
52 tools, named exactly as below. In direct mode the twelve RushDB Cloud tools are not listed. The full reference, with inputs and safety levels, is at docs.rushdb.com/3.x/learn/reference/mcp/tools.
Discovery and properties
Tool | What it does |
| The whole graph schema as compact Markdown; call once at session start |
| Structured schema JSON, with property IDs and vector indexes |
| List or filter record labels and their counts |
| Property names, types, IDs and record counts |
| Metadata for one property |
| Numeric or date ranges, or distinct values; with |
| Where a value from the question is stored: matches across every property, with label, property and record count |
| Every label's properties with distinct counts, ranges and the values of small fields, in one live read |
| The real label or property behind a name that is not in the schema ( |
| How labels reference each other, from property names and exact value containment, with evidence (RushDB Cloud only) |
| Remove a property and its values from all records |
| The complete SearchQuery syntax reference |
| The built-in query builder prompt (for clients without MCP Prompts support) |
Records
Tool | What it does |
| Search records; ordering, projections, grouping and aggregations |
| The first matching record |
| Exactly one matching record; fails on zero or several |
| One record by ID |
| Several records by ID |
| Insert or upsert one record |
| Update some fields of a record |
| Replace all fields of a record |
| Delete one record by ID |
| Insert or upsert many records with one label |
| Delete the records matching a query |
| Export matching records as CSV |
Relationships
Tool | What it does |
| Find relationships by type, properties or endpoint records |
| Create relationships between existing records |
| Change or remove properties on existing relationships; |
| Remove relationships: every type unless |
Vector, keyword and hybrid search
Tool | What it does |
| List embedding indexes and their status |
| Create an embedding index (on a self-hosted engine, an external one with |
| How many records an index covers and has vectors for |
| Write your own vectors to an external index |
| Delete an embedding index and its vectors |
| Rank records by vector similarity after exact filtering; add |
| Deprecated alias for |
| List text indexes and their status |
| Declare a BM25 text index over one property, or |
| Drop a text index |
| Keyword (BM25) search after exact filtering |
RushDB Cloud only
Tool | What it does |
| Turn a natural-language request into SQL and run it |
| List inferred relationship patterns and analysis status |
| Queue schema analysis for relationship suggestions |
| Approve and apply a suggested pattern |
| Ignore a suggested pattern |
| Delete a pattern and optionally its materialized relationships |
Connections and imports (RushDB Cloud only)
Data synced from SaaS tools (CRM, billing, support, issue tracking, docs, spreadsheets) and background file imports. The agent checks freshness before answering about recent data and offers a sync rather than starting one unasked.
Tool | What it does |
| The project's connections: status, schedule, last success and error, per-stream label, record count and last sync |
| One connection by id (credentials are never returned) |
| Start a sync now, of every enabled stream or the ones named ( |
| Import runs (file imports and connection syncs), filterable by |
| One run's status, per-file or per-stream progress, error sample and summary |
Utilities
Tool | What it does |
| Setup instructions for your MCP client |
Writes accept an optional transactionId.
Built-in query builder prompt
RushDB exposes a system prompt via the MCP Prompts API that teaches the agent to query safely — discover labels and properties first, then construct queries.
How it works:
Client calls
prompts/list→ findsrushdb.queryBuilderClient calls
prompts/get→ injects it as the session system messageAgent now does discovery-first queries automatically
Most MCP clients handle this at session start. If your client doesn't support MCP Prompts, call getQueryBuilderPrompt and inject the result as your system message.
Environment variables
These apply to local (API key) mode. Remote OAuth connections do not use environment variables.
Variable | Required | Description |
| yes | Your RushDB API key |
| no | API base URL (default: |
For standalone direct mode, use these instead:
Variable | Required | Description |
| yes | Set to |
| yes | Standalone engine base URL, for example |
| yes | Token configured for the standalone engine. |
| no | Tenant on an engine started with |
Registry & autodiscovery
mcp.yamlat the repo root enables autodiscovery by MCP registriesglama.jsonat the repo root contains Glama metadataPackage:
@rushdb/mcp-server, command:npx
Development
git clone https://github.com/rush-db/mcp-server
cd mcp-server
npm install
npm run buildTroubleshooting: rushdb-mcp: command not found / MCP error -32000
This only happens when the MCP client launches the server with a working directory inside this repo (e.g. an .mcp.json at the repo root used by Claude Code / Cursor). This repo is @rushdb/mcp-server, so an unversioned npx @rushdb/mcp-server (even with -p) can resolve to the local package, whose rushdb-mcp bin isn't linked in node_modules/.bin. The process exits before the MCP handshake, which the client reports as -32000.
The published package is unaffected — the config above works as-is outside the repo. To run from inside the repo, pin a version so npx fetches from the registry instead of resolving the local package:
{
"mcpServers": {
"rushdb": {
"command": "npx",
"args": ["-y", "-p", "@rushdb/mcp-server@latest", "rushdb-mcp"],
"env": { "RUSHDB_API_KEY": "your-api-key-here" }
}
}
}Alternatively, run the local build directly (uses your in-repo code, must be built first with npm run build):
{
"mcpServers": {
"rushdb": {
"command": "node",
"args": ["build/index.js"],
"env": { "RUSHDB_API_KEY": "your-api-key-here" }
}
}
}License
Apache 2.0
Available Tools
48 toolsanalyzeRelationshipPatternsA
Queue schema analysis to generate relationship pattern suggestions for the current project. This may invoke the configured LLM. Poll listRelationshipPatterns to inspect completion status and suggestions.
Inputs: no named parameters. Returns: queued
approveRelationshipPatternA
Approve and apply a suggested relationship pattern. Call listRelationshipPatterns first so the user can review the inferred source, target, direction, type, mode, and confidence.
Inputs: id (required). Returns: pattern
attachRelationA
Create a directed or bidirectional relationship between records. sourceId and targetId/targetIds must already exist — use findRecords to resolve records by name/attribute first.
Inputs: sourceId (required), targetId, direction, targetIds, +3 more. Returns: message, success
bulkCreateRecordsA
Insert multiple records of the same label in one call. Set mergeStrategy ("append" to keep existing unspecified fields, "rewrite" to replace) and mergeBy (fields to match on) in options to enable upsert semantics. Use the exact label casing returned by findLabels.
Inputs: data (required), label (required), options, transactionId. Returns: ids, data, total, message
bulkDeleteRecordsADestructive
Delete all records matching a query. IRREVERSIBLE and potentially high-impact. REQUIRED: always call findRecords with the same labels+where first to show the user a preview, then ask for explicit confirmation before calling this tool.
Inputs: where (required), labels, transactionId. Returns: message, success
createEmbeddingIndexA
Create a new embedding index policy for a string property. For managed indexes (default), RushDB asynchronously embeds every existing value and keeps new values embedded on write. For external indexes (sourceType: "external"), the client supplies vectors via upsertEmbeddingVectors. Once the index status becomes "ready" (check with getEmbeddingIndexStats), use vectorSearch to query.
Inputs: label (required), propertyName (required), name, dimensions, +2 more. Returns: index
createRecordA
Create a new record. Use the exact label casing returned by findLabels. Set mergeStrategy + mergeBy in options to enable upsert semantics (merge existing vs. replace).
Inputs: data (required), label (required), options, transactionId. Returns: id, record, message, success
createTextIndexA
Declare a keyword (BM25) text index over one property of a label, or every string of it (property "*"). It is built online; once its status is "ready" (listTextIndexes), search it with textSearch or as the text leg of vectorSearch.
Inputs: label (required), property (required), name, consistency. Returns: index
deleteEmbeddingIndexADestructive
Delete an embedding index policy by its ID and strip all stored embedding vectors for that index. Irreversible. Confirm with the user before calling. Use findEmbeddingIndexes to get the indexId.
Inputs: indexId (required). Returns: result
deletePropertyADestructive
Permanently delete a property and all its values from every record that has it. Irreversible. Confirm with the user before calling.
Inputs: propertyId (required). Returns: message, success, property
deleteRecordADestructive
Delete a single record by ID. Irreversible. Always confirm with the user before calling. Use findRecords to preview the record first.
Inputs: recordId (required), transactionId. Returns: message, success
deleteRecordByIdADestructive
Delete a single record by ID. Irreversible. Always confirm with the user before calling. Use getRecord to preview the record if needed.
Inputs: recordId (required), transactionId. Returns: message, success
deleteRelationshipPatternADestructive
Delete a saved relationship pattern. Irreversible. Confirm with the user before calling. When deleteExisting is true, relationships previously materialized by this pattern are also removed.
Inputs: id (required), deleteExisting. Returns: deleted
deleteTextIndexADestructive
Drop a text index by name. Irreversible. Confirm with the user before calling.
Inputs: name (required). Returns: deleted
detachRelationADestructive
Remove the relationships between a record and target records. Without relationType it removes relationships of every type; with direction "bidirectional" it removes them both ways. Not available inside a transaction. Use findRelationships to inspect existing relationships and confirm the correct type/direction before detaching.
Inputs: sourceId (required), targetId, direction, targetIds, +1 more. Returns: message, success
exportRecordsARead-only
Export matching records as a CSV file only when the user explicitly asks to export/download CSV. For normal reading, answering, listing, searching, or inspecting records, use findRecords instead. Accepts the same labels/where/orderBy filters as findRecords. Call findProperties first to know available field names if constructing a where filter.
Inputs: limit, where, labels, orderBy. Returns: csv, message, dateTime
findEmbeddingIndexesARead-only
List all embedding index policies configured for the current project. Each index entry contains: id, label, propertyName, modelKey, dimensions, enabled, status (pending|indexing|ready|error), createdAt, updatedAt. Call this before creating a new index to check if one already exists for the same label+propertyName.
Inputs: no named parameters. Returns: indexes
findLabelsARead-only
List or filter available record types (labels) and their counts. IMPORTANT: getSchemaMarkdown already returns ALL label names in STEP 0 — do NOT call findLabels as a substitute for it. Only call findLabels when you need label counts after applying record-scoped predicates, or getSchemaMarkdown was not called yet. Call with no arguments to list all labels. where is applied to Records, not label metadata; use getSchemaMarkdown to search label names. Returns objects with name (case-sensitive — use exact casing in all subsequent calls) and count (number of matching records). Pick the best matching label by: exact match > starts-with > substring > semantic similarity, preferring higher count on ties. State your label assumption briefly ("using DEAL for 'deals'") and proceed without asking.
Inputs: skip, limit, where, orderBy. Returns: labels
findOneRecordARead-only
Return the first record matching the query — useful for entity resolution probes. Call with where: { : { $contains: "..." } } and a small limit to resolve a named entity to its ID before using it in a relationship filter. Prefer this over findRecords when you need exactly one representative match rather than a full list.
Inputs: where, labels. Returns: record
findPropertiesARead-only
Discover the field names, types, and IDs available on a record label. Always call this before using field names in any query — never guess or invent field names. Filter by label using labels: ["LABEL_NAME"]. where is applied to Records, not property metadata. Each returned property object has: id (string), name (string), type (string | number | boolean | datetime), recordsCount (number of records that carry this property). Use the name field as the field name in where/orderBy/groupBy clauses. Use the id field as the propertyId argument to propertyValues. After calling this tool, decide the next step based on the field type: number or datetime → call propertyValues(propertyId) to get { min, max } for range questions, OR use findRecords with select: { min: ..., max: ... }; string or boolean → call propertyValues(propertyId) to get distinct values before filtering.
Inputs: skip, limit, where, orderBy. Returns: properties
findPropertyByIdARead-only
Fetch the metadata (name, type, label, recordsCount) of a single property by its ID. Use when you already have a propertyId and need to re-confirm its type or cardinality before calling propertyValues.
Inputs: propertyId (required). Returns: property
findRecordsARead-only
Primary read/query/list/search tool for records. Use findRecords to find records, search records, list records, retrieve matching records, filter records, or answer questions from data. Use this instead of exportRecords unless the user explicitly asks for CSV/export/download. Search records with a structured SearchQuery. BEFORE building any query with dates, metrics, groupBy, relationship traversal, or vector search — call getSearchQuerySpec to load the complete syntax reference. INTENT: metrics/analytics request (count/total/sum/avg/breakdown/top N by metric) → MUST include select + groupBy. NEVER fetch raw records to count/sum manually. RESPONSE: { data:[...records], total:N } — for simple "how many" read total directly; no count select needed. HARD RULES: (1) NEVER set limit when select is present — restricts the record scan and produces mathematically wrong results. Omit limit for all metrics queries. (2) labels contains root records only; put related labels inside where traversal blocks with $alias when referenced. (3) groupBy never accepts alias-only values like "$record"; use "$record.name" or a select key. (4) Ambiguous/incomplete named references should use $contains on a display property confirmed via schema discovery, not exact equality. (5) Related-count rankings keep the requested parent/entity as root; count the related alias and order desc for most/more or asc for least/less/fewer.
Inputs: skip, limit, where, labels, +3 more. Returns: data, total
findRelationshipsARead-only
Discover and traverse relationships between records. Use this tool in two scenarios: (1) Multi-hop path discovery — fetch a sample record ID, then call findRelationships with source.where or target.where containing that ID to reveal adjacent labels; repeat to trace the full path before building a nested findRecords where clause. (2) Edge filtering — where applies to relationship type/properties; use source/target for endpoint record predicates. Does NOT support select or groupBy — use findRecords for metrics/analytics across related labels.
Inputs: skip, limit, where, source, +2 more. Returns: relationships
findUniqRecordARead-only
Return the single record that uniquely matches the query — throws if zero or more than one record matches. Use for unique-key lookups (email, code, slug) where exactly one result is expected. Use findOneRecord instead when you only want the first match and duplicates are acceptable.
Inputs: where, labels. Returns: record
getEmbeddingIndexStatsARead-only
Return indexing statistics for an embedding index: totalRecords and indexedRecords. Use this to monitor backfill progress after creating an index — when indexedRecords === totalRecords the index is fully ready.
Inputs: indexId (required). Returns: stats
getJoinCandidatesARead-only
Which properties reference records of another label (or the same one), found from property names and exact value containment, with evidence (matched values and records, coverage). RushDB Cloud only. Use it to learn how labels connect when the data has no relationships yet, e.g. before joining in a query. Returns [{ source, target, reasons, relationshipType, confidence, evidence, rationale }].
Inputs: labels, minConfidence. Returns: candidates
getQueryBuilderPromptARead-only
Return the RushDB system prompt. Use this if your MCP client does not support the Prompts API.
Inputs: no named parameters. Returns: prompt
getRecordARead-only
Fetch a single record by its ID. Use when you already have the ID from a previous findRecords or findOneRecord call.
Inputs: recordId (required). Returns: record
getRecordsByIdsARead-only
Fetch multiple records by their IDs in one call. Use after collecting IDs from a findRecords query.
Inputs: recordIds (required). Returns: data, total
getSchemaARead-only
Returns the same graph schema as getSchemaMarkdown but as structured JSON. Each item has: label (string), count (number), properties (array with id, name, type, optional isArray, recordsCount (number of records that carry this property), min/max for numbers/datetimes, values[] for strings/booleans, and an optional vectorIndexes array), and relationships (array with label, type, direction: in|out, count, and optional edge properties). vectorIndexes is non-empty when one or more embedding indexes exist for that property; each entry has: id, sourceType (managed|external), similarityFunction (cosine|euclidean), dimensions (number), status (pending|indexing|ready|error), modelKey. A non-empty vectorIndexes means the property is queryable with aiSemanticSearch. Use this when you need property id values to pass to propertyValues for deeper drill-down. For initial schema orientation, getSchemaMarkdown uses fewer tokens. Pass force: true to bypass the 1-hour schema cache and force a fresh recalculation.
Inputs: force, labels. Returns: schema
getSchemaMarkdownARead-only
STEP 0 — call this ONCE at the start of every conversation before constructing any query. Returns the complete graph schema as compact Markdown: all labels with record counts, all properties per label with their type and value ranges (min/max for numbers/datetimes, sample values for strings/booleans; array properties render as type[]), and all cross-label relationships with direction and edge property summaries. The Properties table includes a "Semantic Search" column: properties with an embedding index show sourceType similarityFunction dimensionsd [status] (e.g. managed cosine 1536d [ready]); others show —. A non-— value means the property is queryable with aiSemanticSearch. This single call replaces the need for separate findLabels + findProperties + findRelationships discovery calls. Use the result to determine exact label names (case-sensitive), field names, field types, and relationship patterns before building any findRecords query. Optionally pass labels array to narrow the output to specific labels. Pass force: true to bypass the 1-hour schema cache and force a fresh recalculation.
Inputs: force, labels. Returns: markdown
getSchemaSummaryARead-only
Every label with its properties in one live read (never cached): per property its type, record count, exact distinct count, min/max for numbers and dates, and the full value list when it holds few (fewValues, default 10); per label its relationships. Use it to learn how values are coded (e.g. KCT holds "-" and "+") without one call per field.
Inputs: labels, fewValues. Returns: labels
getSearchQuerySpecARead-only
Returns the complete RushDB SearchQuery specification as a focused reference document. Covers: all WHERE operators (string/number/boolean/datetime component objects/vector/$exists/$type), relationship traversal syntax ($alias/$relation with variable-length hops/$cycle ring detection/$id), logical grouping ($and/$or/$not/$nor/$xor), all select functions ($sum/$avg/$min/$max/$count/$collect/$timeBucket), both groupBy modes (dimensional + self-group), late-ordering rules, root-label vs related-label traversal rules, COLLECT nesting, limit rules by query mode, multi-hop path discovery, enum normalization, validation checklist, and annotated query examples. CALL THIS before building any findRecords query that involves dates, metrics, groupBy, relationship traversal, or vector search. Do not guess operator syntax — use this spec as the source of truth.
Inputs: no named parameters. Returns: spec
helpAddToClientARead-only
Help the user add the RushDB MCP server to their MCP client
Inputs: no named parameters. Returns: instructions
ignoreRelationshipPatternA
Ignore a suggested relationship pattern without applying it. Call listRelationshipPatterns first so the user can review the inferred pattern.
Inputs: id (required). Returns: pattern
listRelationshipPatternsARead-only
List inferred relationship patterns for the current project. Returns suggestions and their lifecycle status, current schema relationship summaries, and the latest analysis status. Use this before approving, ignoring, or deleting a relationship pattern.
Inputs: no named parameters. Returns: analysis, patterns, relationships
listTextIndexesARead-only
List the project's keyword (BM25) text indexes: name, label, property ("*" = every string of the record), consistency and status.
Inputs: no named parameters. Returns: indexes
propertyValuesARead-only
Get statistics or distinct values for a specific property, identified by the id field returned from findProperties. What this tool returns depends on the property type:
• number / datetime → returns { min, max } — use this to answer range, min/max, or spread questions for numeric or date fields. No findRecords aggregation needed.
• string / boolean → returns a list of all distinct values — use this to canonicalize filter values before querying.
Workflow for range/min/max questions: (1) findLabels, (2) findProperties to find the field and get its id and type, (3) call this tool with that id if type is number or datetime.
Inputs: propertyId (required), skip, limit, match, +3 more. Returns: propertyValues
resolveNamesARead-only
Find the real label or property behind a name you are unsure of (case, separators and plural endings ignored, then ranked by spelling): "patients" → Patient, "patients.birthdate" → Patient.Birthday. Call it instead of guessing when a label or field name is not in the schema. Returns [{ label, property?, score }].
Inputs: text (required), limit. Returns: names
searchValuesARead-only
Find where a value from the question is stored: searches the exact value dictionaries of every property at once and returns { matches: [{ label, property, value, count }], total }. Use it before filtering on a name, code, or phrase the user typed, instead of guessing the field or spelling. match: contains (default), prefix, exact, or similar (near spellings, for typos and punctuation: "spiderman" finds "Spider-Man"). No match means no stored value contains the text: check the spelling, try a shorter word, or read a field's values with propertyValues.
Inputs: text (required), limit, match, labels, +1 more. Returns: searchValues
semanticSearchARead-only
Deprecated alias for vectorSearch. Performs direct vector similarity search over records whose propertyName has been indexed with createEmbeddingIndex. Prefer vectorSearch for new integrations. For natural-language schema-aware querying, use smartSearch.
Inputs: labels (required), propertyName (required), ef, mode, +9 more. Returns: data, total
setRecordADestructive
Replace ALL fields of a record with the provided data object — any existing fields not in data are deleted. Use updateRecord instead for partial/merge updates that preserve unspecified fields.
Inputs: data (required), label (required), recordId (required), transactionId. Returns: record, message, success
smartSearchARead-only
Convert a natural-language question into one read-only SQL statement over the project schema, run it, and return the results plus the statement, a short title for it and any warnings. Rows that select a record come back as records; aggregates such as counts and totals come back as plain rows. Use this for user-facing questions such as "Who are piloting Falcon?" or "How many orders per city?". For direct vector similarity over an embedding index, use vectorSearch instead.
Inputs: prompt (required), skip, limit. Returns: sql, data, name, total, +1 more
textSearchARead-only
Keyword (BM25) search over a text index: records matching query, best first (__score), among those labels and where select. total counts every match. Query syntax: words match any (or all with allTerms), "quoted phrases", -excluded, +required.
Inputs: query (required), skip, index, limit, +5 more. Returns: data, total
updateRecordA
Partially update a record — only fields present in data are changed; all other existing fields are preserved. Use setRecord instead if you want to replace all fields. Requires recordId: retrieve it first with findRecords or getRecord if not already known.
Inputs: data (required), label (required), recordId (required), transactionId. Returns: record, message, success
updateRelationA
Change the properties of existing relationships of one type between a record and target records: set writes values (null stores an explicit null), unset removes properties. Pairs without such a relationship are skipped; updated counts the relationships changed. Not available inside a transaction. Use findRelationships first to confirm the relationship type, direction and current properties.
Inputs: sourceId (required), relationType (required), set, types, +4 more. Returns: message, success, updated
upsertEmbeddingVectorsA
Write pre-computed embedding vectors to an external vector index for a set of records. Only valid for indexes with sourceType "external". Each vector must contain exactly as many dimensions as the index was created with. After upserting, call getEmbeddingIndexStats to check if all records are indexed (status becomes "ready").
Inputs: items (required), indexId (required). Returns: result
vectorSearchARead-only
Perform direct vector similarity search over records whose propertyName has been indexed with createEmbeddingIndex. For managed indexes: provide a free-text query — RushDB embeds it and returns the most similar records ranked by similarity (__score). For external indexes: provide a queryVector (pre-computed number[]) instead of query text. A where filter narrows candidates before ranking. Requires an embedding index in "ready" status for the given label+propertyName.
Inputs: ef, mode, rrfK, skip, +15 more. Returns: data, total
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 48 tools
Many tools overlap heavily: six-plus schema-discovery tools (getSchemaMarkdown, getSchema, getSchemaSummary, findLabels, findProperties, findPropertyById), duplicate deletes (deleteRecord vs deleteRecordById), near-duplicate reads (findRecords/getRecord/getRecordsByIds/findOneRecord/findUniqRecord), overwrite vs partial semantics (setRecord vs updateRecord), and an explicitly deprecated alias (semanticSearch for vectorSearch). The descriptions do try to disambiguate, but an agent must read paragraphs of guidance each time to pick correctly, and redundancy remains.
All names use camelCase and nearly all follow a verb_noun pattern (createRecord, findRelationships, deleteEmbeddingIndex, bulkCreateRecords). A handful (propertyValues, searchValues, resolveNames, smartSearch, helpAddToClient) are noun-first rather than verb-first, which is a minor deviation but still readable and predictable.
48 tools is well past the point where a set stays legible; the schema-discovery and search areas alone account for nearly twenty overlapping entries. Consolidating getSchemaMarkdown/getSchema/getSchemaSummary, deleteRecord/deleteRecordById, and semanticSearch into vectorSearch would cut the surface substantially without losing capability.
Record CRUD, bulk operations, relationship attach/detach/update, schema introspection, pattern inference, embedding and text index lifecycle, vector/keyword/NL search, and CSV export are all present, which is strong coverage for a graph database service. The main gaps are around transactions (tools note they are unavailable inside one) and lack of explicit transaction/session management tools.
Maintenance
Related MCP Connectors
Persistent memory for AI agents. Search and store durable facts, preferences and decisions.
Persistent memory for AI agents. Semantic search, memory graph, W3C DID identity.
Universal memory for AI agents and tools. Save, organize and search context anywhere.
Hosted persistent memory with semantic search, importance and TTL for AI agents.
Related MCP Servers
AlicenseAqualityDmaintenanceProvides persistent long-term memory for AI agents through semantic search and automated knowledge graph extraction. It enables agents to store, recall, and reason over facts, preferences, and relationships across multiple conversations and sessions.1417 npmMIT- AlicenseAqualityDmaintenanceEnables AI agents with persistent semantic memory, including semantic recall, knowledge graphs, and instant domain expertise via pre-built Intelligence Packs.1051 npmMIT
- AlicenseAqualityCmaintenanceProvides persistent, searchable memory for AI agents, enabling them to retain, recall, and reflect on information across conversations.1932 PyPI1MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to maintain persistent, local memory with retrieval-augmented search, knowledge graphs, and context surfacing, without any cloud dependencies.276 npmMIT