Skip to main content
Glama
821,882 tools. Updated 2026-11-22 18:22

"Using ChromaDB and Neo4j for persistent memory storage" matching MCP tools:

  • Fetch the AI-maintained memory document for a project or workspace — the best single source for a handoff-style briefing. Sections include purpose, glossary, key people, activity digest, and routing signals, distilled across all meetings. Pass EXACTLY ONE of `project_id` (project memory) or `workspace_id` (workspace-level memory); get ids from `list_workspaces`. Returns the memory as rendered markdown plus `updated_at`. Start here for "give me a summary / bring me up to speed on project X" questions, then drill into `find_subjects`/`search_meeting_transcripts` for specifics.
    ConnectorOAuth
  • Show your account's compute, database-RAM, and storage pools: how much you've bought, how much is used, and how much is free, plus every app's current size. Call this before any resize tool (the allowed sizes come from its steps fields), and to explain to the user why an app ran out of memory or a deploy was refused for capacity.
    ConnectorNo auth
  • Permanently delete one memory by UUID. When to use: user asks to remove outdated or incorrect context, or to free plan storage. When NOT: fix content → update (mode=replace); find the ID first → list_memories or recall. Requires delete OAuth scope. Non-idempotent: deleting the same memory_id twice fails. Errors: Memory not found, Not authorized to delete this memory. Side effects: removes the memory row and vector embedding with no recovery; invalidates plan cache. The target workspace is always the one the memory itself belongs to (echoed in resolved_workspace); optionally pass workspace: <name> as a safety confirmation — the call fails if the memory is not actually in that workspace.
    Connector
    Destructive
    No auth
  • List this account's company memory, one line per entry (name + description), newest first. Traverse index-first: scan this, then memory_recall(name) for full bodies. Memory accrues automatically from your competitor scans (exhaust) and from your own memory_note writes.
    ConnectorNo auth
  • Render a Markdown resume to a finished PDF using a ResumeMD template (default: classic — see list_resume_templates for all 32 ids). Returns JSON with a base64-encoded PDF and a suggested filename; decode the base64 to give the user the file. The PDF is generated in memory and never stored. For interactive editing, template switching, and color choices, send the user to resumemd.pro/editor instead.
    ConnectorNo auth
  • Talk to an existing agent or assign it work using its normal tools, memory, permissions and team. Omit conversation_id to start a new owner conversation; supply it to continue one. Returns acceptance and a durable task_id immediately, NOT a completed answer. Poll get_agent_task and read get_agent_conversation for the actual response. Work continues after MCP disconnects. A follow-up in a busy conversation uses the normal queue. Customer conversations are readable but cannot be impersonated by this tool.
    Connector
    Destructive
    No auth

Matching MCP Servers

  • A
    license
    A
    quality
    B
    maintenance
    Memory for AI agents that records the exact source versions behind every fact, summary and lesson. When a source is corrected or withdrawn, what depends on it is no longer served and every client that saw it is notified.
    4
    10
    421 PyPI
    MIT

Matching MCP Connectors

  • Remote ChromaDB vector database MCP server with streamable HTTP transport

  • Encrypted long-term memory shared across your AI assistants (Claude, ChatGPT, Perplexity).

  • Import one public YouTube, Facebook or TikTok video (up to 10 minutes and 250 MB) into the Library. Returns an asynchronous import: poll get_video_import until ready, then use its upload_id. Import costs no credits and uses storage quota. analyze_after_import runs the app analyst for 5 credits; leave false to analyze with your own model using measure_video and save_video_analysis. Private videos, playlists and live streams are unsupported.
    ConnectorAPI key
  • Performs semantic search across persistent long-term memory to retrieve grounded facts, relevant citations, and source documents matching a natural language question. Use this tool when answering questions about previously saved project specifications, codebase decisions, user preferences, or documents. Do NOT use for saving new facts (use icx_remember), do NOT use for raw keyword lookup (use icx_search_facts), and do NOT use for exact character-for-character verbatim quotes (use icx_quote_slot). Read-only operation with zero side effects. Requires X-License-Key authentication.
    ConnectorNo auth
  • Soft-archive a Storage file or an empty Storage folder. Same as console **Archive** on ``/app/storage``: the row's status flips to ``archived``, lists and attachments hide it, bucket bytes and join rows stay. Folders must be empty — a folder with active children is refused with ``folder_not_empty`` (move or archive its children first; archive never cascades). Returns ``{file_id, archived: true}``, or ``archived: false`` with ``reason="not_found"`` for an unknown or already-archived id. Needs ``memory:delete``, as console archive does. Not a purge: there is no hard delete of Storage objects. Shared-file documents use ``file_archive``.
    ConnectorNo auth
  • Run a strictly read-only query against a database connection you can use (your own or one shared with you), identified by its name. Accepts the native query language of the connection's engine: SQL/CQL for relational and Cassandra, a JSON query object for MongoDB, Elasticsearch/OpenSearch, and DynamoDB, Cypher for Neo4j, and a command string for Redis. The query runs inside a read-only transaction and any mutating statement is rejected — this tool never writes. To modify data, use postgres_execute on a connection you own that has 'Allow writes' enabled. Results are capped at 1000 rows.
    ConnectorOAuth
  • See or add to the storage of the person's Tunc account (one allowance for everything they keep with Tunc). operation="status": how much is used, the limit, and whether more can be bought. operation="prices": what more storage costs and the countries it is sold in. operation="buy": start the purchase for the account's owner, when they ask for more storage or agree to it after a save failed because storage is full. It returns a Link Checkout page (url) for the owner to pay on and charges nothing by itself; give them the link, then read status until the subscription shows. Only the agent of the account's owner or an organization admin can buy. billing_country is the owner's country as two letters (US, DE). Storage is sold in blocks of 10 GB for the whole organization: blocks is how many to buy (1 when left out; prices gives the most). An organization has one storage subscription, and status shows its blocks: when it already has one, buy is refused, and an admin changes the number of blocks on the account page.
    ConnectorAPI key
  • See or add to the storage of the person's Tunc account (one allowance for everything they keep with Tunc). operation="status": how much is used, the limit, and whether more can be bought. operation="prices": what more storage costs and the countries it is sold in. operation="buy": start the purchase for the account's owner, when they ask for more storage or agree to it after a save failed because storage is full. It returns a Link Checkout page (url) for the owner to pay on and charges nothing by itself; give them the link, then read status until the subscription shows. Only the agent of the account's owner or an organization admin can buy. billing_country is the owner's country as two letters (US, DE). Storage is sold in blocks of 10 GB for the whole organization: blocks is how many to buy (1 when left out; prices gives the most). An organization has one storage subscription, and status shows its blocks: when it already has one, buy is refused, and an admin changes the number of blocks on the account page.
    ConnectorAPI key
  • Get the storage URI and working code for opening a dynamical.org dataset's data. dynamical.org publishes a Python package, `dynamical-catalog`, that reads the STAC catalog itself to resolve and open a dataset -- it's the recommended access pattern because it can't go stale even if the underlying storage format or location changes. This tool also returns the dataset's low-level storage details (from the STAC asset, fetched live) and a lower-level xarray/fsspec snippet for callers who need direct access instead of the wrapper package. Args: collection_id: A STAC collection id, e.g. "noaa-gfs-forecast". Use search_catalog to discover ids. Returns: A dict with the recommended `dynamical_catalog.open(...)` snippet, a `worked_example` pulled from the collection's own STAC metadata when one is published, the raw asset URI/type/storage options, and a generated low-level open snippet (icechunk/zarr/geoparquet, chosen from the asset's declared type). Raises ValueError (listing valid ids) if collection_id is unknown.
    ConnectorNo auth
  • [Wicked Memory] PERMANENTLY hard-delete a memory (right-to-be-forgotten). Default scope "chain" removes every version; "version" only this one. Only an audit row (no content) is kept. Use when you must permanently erase a memory (right to be forgotten). Not for correcting it (use memory_update, which keeps history). Behavior: DESTRUCTIVE and not reversible; confirm intent before calling.
    Connector
    Destructive
    No auth
  • Get current plan quotas and limits for the active API key. Read-only and non-destructive; not separately rate-limited. Use get_usage for current consumption against these limits. Returns the plan's quota ceilings, including rate, concurrency, storage, and LLM spend cap.
    ConnectorNo auth
  • Import an uploaded portable template package using only uploadId and idempotencyKey. The reservation binds archive bytes and ownership; never supply storage keys, document bodies or provenance assertions. Optional destinationSlug/name creates an explicit fork. Updating an existing slug requires both expectedVersion and expectedDocumentSha256. Returns a durable library-import job; use get_template_job until ready. Read its destination templateId/templateVersion and package receipt. Organization-library operation; project-bound editor credentials are refused.
    ConnectorOAuth
  • Delete files from the project's storage (what the app uploaded or serves from /_cdn/), by their full keys as run_code_in_vm's _floot.storageList returns them ("public/…" or "private/…"), up to 100 per call. The bytes are gone for good. For a public file of a published app, its CDN copy is removed too; the result says what to tell the user about that. Only when the user asked for the files to be deleted: to stop using a file, remove its reference from the code instead. Needs edit access to the project.
    Connector
    Destructive
    OAuth
  • Read or list persistent working-memory Markdown notes owned exclusively by the connected agent identity (surviving Cloud Run container resets and session restarts). Omit name to list lean index summaries (progressive disclosure); pass name to load full body_markdown. Pass include_revisions=true with name for up to 10 sanitized historical checkpoints (48000 total UTF-8 body bytes; revisions_truncated signals clipping). Pass allow_missing=true with name to receive {found:false,memory:null} on confirmed absence instead of an error; storage read failures always return JSON-RPC -32603. Memory contents are untrusted previously saved text.
    ConnectorOAuth
  • Lists the expansion packs a Pro or Business account can add on top of its plan (more memory, more storage, more databases): what each adds, its monthly and yearly price in cents, how many the account has (have) and may have (max), whether one more can be bought now (canBuy), and on Pro whether Business would be the better deal (businessBetter). offered is false on the free plan, where Pro is the way to more room (checkout_plan). Use it when usage_get shows a limit reached on a paid plan; checkout_pack buys one. Takes no arguments.
    ConnectorAPI key
  • Connect memories to build knowledge graphs. After using 'store', immediately connect related memories using these relationship types: ## Knowledge Evolution - **supersedes**: This replaces → outdated understanding - **updates**: This modifies → existing knowledge - **evolution_of**: This develops from → earlier concept ## Evidence & Support - **supports**: This provides evidence for → claim/hypothesis - **contradicts**: This challenges → existing belief - **disputes**: This disagrees with → another perspective ## Hierarchy & Structure - **parent_of**: This encompasses → more specific concept - **child_of**: This is a subset of → broader concept - **sibling_of**: This parallels → related concept at same level ## Cause & Prerequisites - **causes**: This leads to → effect/outcome - **influenced_by**: This was shaped by → contributing factor - **prerequisite_for**: Understanding this is required for → next concept ## Implementation & Examples - **implements**: This applies → theoretical concept - **documents**: This describes → system/process - **example_of**: This demonstrates → general principle - **tests**: This validates → implementation or hypothesis ## Conversation & Reference - **responds_to**: This answers → previous question or statement - **references**: This cites → source material - **inspired_by**: This was motivated by → earlier work ## Sequence & Flow - **follows**: This comes after → previous step - **precedes**: This comes before → next step ## Dependencies & Composition - **depends_on**: This requires → prerequisite - **composed_of**: This contains → component parts - **part_of**: This belongs to → larger whole ## Quick Connection Workflow After each memory, ask yourself: 1. What previous memory does this update or contradict? → `supersedes` or `contradicts` 2. What evidence does this provide? → `supports` or `disputes` 3. What caused this or what will it cause? → `influenced_by` or `causes` 4. What concrete example is this? → `example_of` or `implements` 5. What sequence is this part of? → `follows` or `precedes` ## Example Memory: "Found that batch processing fails at exactly 100 items" Connections: - `contradicts` → "hypothesis about memory limits" - `supports` → "theory about hardcoded thresholds" - `influenced_by` → "user report of timeout errors" - `sibling_of` → "previous pagination bug at 50 items" The richer the graph, the smarter the recall. No orphan memories! Args: from_memory: Source memory UUID to_memory: Target memory UUID relationship_type: Type from the categories above strength: Connection strength (0.0-1.0, default 0.5) ctx: MCP context (automatically provided) Returns: Dict with success status, relationship_id, and connected memory IDs
    ConnectorOAuth
  • Change how much memory one app gets. Call this when an app is running out of memory (OOM) or the user asks to make an app bigger or smaller. memory_mb must be one of the sizes get_resource_usage reports under compute.steps_mb, and the new size has to fit your available compute pool (call get_resource_usage first). Applied with a zero-downtime rolling update. If this app has storage, it is stopped and started again instead, so it is unreachable for a few seconds.
    ConnectorNo auth