Potencialize seu agente
Instalação do publicador. Não é um endpoint do PlugMCP.
Host a copy with our keys and logs.
Ainda não há uma versão empacotada no registro. Siga o README do repositório.
URL remota ou um comando na sua máquina? Como as duas instalações diferem
Rodar no PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirShared code intelligence for agent fleets. AST-aware semantic search, multi-agent memory, and git-concurrent coordination.
When multiple AI agents work on the same codebase, they fight. Agent A rewrites a function that Agent B is also modifying. Agent C searches for a pattern that Agent D already found and documented. Agents repeat work, create conflicts, and operate on stale information.
fleet-mem is a local MCP server that gives AI coding agents shared context:
ollama pull nomic-embed-textpip install fleet-mem
Or from source:
git clone https://github.com/sam-ent/fleet-mem.git
cd fleet-mem
./scripts/setup.sh # Creates venv, installs deps, registers MCP server
./scripts/docker-setup.sh
MCP client configuration for Docker:
{
"mcpServers": {
"fleet-mem": {
"command": "docker",
"args": ["exec", "-i", "fleet-mem-fleet-mem-1", "python", "-m", "fleet_mem.server"]
}
}
}
Mount your code as a volume to index it:
# Add to docker-compose.yml under fleet-mem.volumes:
- /path/to/your/projects:/projects:ro
./scripts/index-repos.sh --root ~/projects
Add to your MCP client settings (the setup.sh script does this automatically for the default client):
{
"mcpServers": {
"fleet-mem": {
"command": "python3",
"args": ["-m", "fleet_mem.server"],
"env": {
"OLLAMA_HOST": "http://localhost:11434",
"ANONYMIZED_TELEMETRY": "False",
"FLEET_STATS_SOCK": "~/.fleet-mem/stats.sock"
}
}
}
}
Important: Do not set
"cwd"in the MCP config. Claude Code sets the working directory to the project the agent is working in. A hardcodedcwdbreaks worktree detection and auto-coordination.
fleet-mem works with any MCP-compatible client. Your client starts it automatically on the first tool call.
Once indexed, agents can ask things they could not do with grep:
fleet-mem installs once as a global MCP server. It can index any number of projects. Each project gets its own collection in ChromaDB. All agents share the same server instance.
~/projects/
project-a/ indexed as code_project-a
project-b/ indexed as code_project-b
project-c/ indexed as code_project-c
~/.local/share/fleet-mem/
chroma/ vector embeddings (shared)
memory.db agent memories + FTS + file anchors (WAL mode)
fleet.db locks, subscriptions, sessions, notifications (WAL mode)
embeddings_cache.db embedding vector cache
AST-aware splitting means search results are complete, meaningful code units. Text-only fallback still works but may return partial functions. Adding a new language requires defining its tree-sitter node types in fleet_mem/splitter/ast_splitter.py (contributions welcome).
Problem: Agents read entire files to understand code, burning tokens and missing context across files.
Solution: One-time indexing parses code into semantic chunks and embeds them. Agents search by meaning across the whole codebase.
Problem: Grep requires exact strings. Agents don't know file names or function signatures in unfamiliar code.
Solution: Natural language query returns ranked code snippets with file paths and line numbers. No exact match needed.
Problem: Agents lose everything they learn when a session ends. The next agent re-discovers the same things from scratch.
Solution: Discoveries persist in a shared memory store. Any agent can find them later via keyword or semantic search.
Problem: Concurrent agents modify the same files, causing merge conflicts and wasted work.
Solution: Agents automatically lock files they've modified on their branch. Conflicts are caught immediately, not after hours of wasted effort. If some files overlap with another agent's lock, only the non-conflicting files are locked.
Problem: Agent A discovers something important about the code. Agent B, working in the same area, has no way to know.
Solution: Agents subscribe to file patterns they care about. When another agent stores a discovery matching that pattern, subscribers are notified automatically.
Problem: Agent A merges a PR. Agents B and C are still working on branches that now have stale context. No one tells them.
Solution: Before merging, see exactly which agents, memories, and branches will be affected. After merging, one call notifies everyone and marks stale context.
The default is Ollama (local, free). fleet-mem also ships an OpenAI-compatible adapter that works with any provider offering an OpenAI-style embeddings API.
See .env.example for full configuration. For providers without an OpenAI-compatible API (Cohere, AWS Bedrock, Hugging Face), see docs/custom-embedding-providers.md. The adapter interface is four methods and typically under 30 lines.
lock_acquire or memory_subscribe calls neededgit rev-parse --git-common-dir with --show-toplevel fallbackINSERT...ON CONFLICT DO UPDATE. No duplicate accumulation across restartsmemory_store automatically notifies subscribers matching the file pathAll settings via environment variables or a .env file in the project root. Copy .env.example to get started.
ChromaDB collections are dim-locked at creation — the vector dimension is fixed when a collection is first created and cannot change. If you switch OLLAMA_EMBED_MODEL (or EMBED_MODEL for cloud providers) to a model with a different output dimension (e.g. all-minilm 384-dim ↔ nomic-embed-text 768-dim), fleet-mem detects the mismatch on the affected collection's next insert or query and raises fleet_mem.vectordb.errors.DimMismatchError (added in #47).
The exception carries model_name, model_dim, collection_name, and collection_dim for programmatic recovery (e.g. an automated re-indexer that catches the error and decides whether to drop + rebuild).
To switch models cleanly, drop the affected collections and re-index:
# Drop a single project's index via the MCP tool
clear_index(path="/path/to/project")
Or, for a wholesale reset, remove the on-disk ChromaDB directory and let fleet-mem re-create collections at the new dim on next index:
rm -rf ~/.local/share/fleet-mem/chroma/
Without dim-mismatch detection the failure mode would be either a late ChromaDB error during inserts (recoverable but wasteful) or — worse — silent garbage retrieval at query time, since cosine distance against mismatched-dim vectors is meaningless. DimMismatchError exists to fail fast and steer you to a clean recovery path.
For fast-moving multi-agent work, reduce SYNC_INTERVAL to 30-60. File-watching is also available for near-instant sync — set FILE_WATCHING=true (the default) to detect changes immediately without polling.
scripts/index-repos.shIterates git repositories under --root (max depth 2) and indexes each one. Per-repo failures don't halt the loop by default — the script prints FAILED to index <name>. Continuing... and moves on to the next repo. After all repos are attempted, it prints an Indexed N/M repos. summary and exits non-zero if any repo failed (since #33).
For CI / orchestration use cases that want to abort on the first failure, set FAIL_FAST=1:
FAIL_FAST=1 ./scripts/index-repos.sh --root ~/projects
Exit codes:
0 — all repos indexed successfully1 — one or more repos failed (default mode finished attempting every repo)2 — FAIL_FAST=1 triggered an early exit on the first failureDimMismatchError raised after switching embed modelsYou changed OLLAMA_EMBED_MODEL (or EMBED_MODEL) to a model with a different output dimension. ChromaDB collections are dim-locked at creation. See Switching embed models for the recovery path.
ollama: context-length 400 on batch of N; bisecting (depth=...)Normal recovery behavior. The chunker emitted a chunk that exceeds the embed model's token-context window — the embedder bisects the batch (and, if needed, splits the offending text and averages the resulting vectors) until each input fits. Indexing continues and no data is lost.
If you see this frequently and want to eliminate the recovery overhead, switch to tokenizer-aware mode by setting FLEET_MEM_MAX_CHUNK_TOKENS (see Configuration). This trades a small tokenizers dependency for elimination of the bisect+mean-vector recovery path on dense content (code, non-English text, base64-like blobs).
Already indexed (N chunks). Use --force to re-index. on retryThe scripts/index-repos.sh short-circuit: if a code_<project> collection already exists with chunks in it, the script skips re-indexing that repo. This is the correct behavior for incremental runs — fleet-mem's merkle-tracked sync (every SYNC_INTERVAL seconds) handles deltas separately. To force a full re-index of a specific project, drop its collection first:
# Via the MCP tool
clear_index(path="/path/to/project")
Then re-run scripts/index-repos.sh.
The progress callback fires every 50 files. Most likely the chunker is processing a single very large file or a deeply-nested directory. If the run pauses between callbacks for more than a few minutes, attach py-spy dump --pid <indexer-pid> to inspect the Python stack. If reproducible, please open an issue with a minimal reproducer.
fleet-mem includes OpenTelemetry tracing, structured logging with trace correlation, and a terminal monitoring UI. All disabled by default.
Problem: Multiple agents are working on the same codebase. You can't tell which agents are active, what files they've locked, or whether they're conflicting — until something breaks.
Solution: Agents register on connect. The TUI monitor polls fleet state over a Unix socket and shows agents, locks, subscriptions, and notifications in real time.
No external infrastructure needed. Install the monitor extra, set one env var, and go:
# 1. Install with monitor
pip install fleet-mem[monitor]
# 2. Enable the stats socket (add to your .env or MCP server config)
FLEET_STATS_SOCK=~/.fleet-mem/stats.sock
# 3. Launch the monitor in a separate terminal
fleet-mem monitor
The TUI connects via a Unix domain socket (0600 permissions — only the socket owner can connect, no network exposure). It shows:
d to toggleagent-alpha (30 files) → expand), not a flat table of 800+ rowsKeybindings: q quit, r refresh, f filter by agent ID, d toggle disconnected agents, x prune disconnected sessions from DB
For Docker deployments, the socket is exposed via a named volume (fleet-sock). Mount it on the host to run the monitor:
docker compose up -d
fleet-mem monitor --sock /var/lib/docker/volumes/fleet-mem_fleet-sock/_data/stats.sock
For teams with existing observability infrastructure (Jaeger, Grafana Tempo, Datadog), fleet-mem exports OpenTelemetry spans:
OTEL_ENABLED=true
OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317 # any OTLP-compatible collector
Data plane spans:
Coordination plane spans:
All content is hashed in span attributes for privacy. Raw code and queries never appear in traces.
fleet-mem uses structlog with OpenTelemetry trace context injection. When a span is active, trace_id and span_id are automatically added to every log line — enabling log-to-trace correlation in Grafana, Datadog, or any log aggregator.
The fleet_stats MCP tool returns current metrics without requiring an external collector:
fleet_stats() -> {
collections: {code_myproject: 1523},
total_chunks: 1523,
memory_nodes: 47,
active_locks: 2,
subscriptions: 5,
pending_notifications: 1,
cached_embeddings: 892
}
See roadmap.md for the full plan.
AGPL-3.0
Architecture inspired by claude-context by Zilliz (MIT License). Design patterns informed by their TypeScript reference (vector database abstraction, embedding adapter, Merkle DAG, AST splitter). All code is an original Python implementation with significant additions (agent memory, fleet coordination, hybrid search, staleness detection).
Shared code intelligence for agent fleets — AST-aware semantic search + multi-agent memory with git-concurrent coordination
Ferramentas
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
Este registro não lista nenhuma variável de ambiente obrigatória.
Fleet Mem roda localmente via stdio.
Última verificação: 2026-10-28. Shared code intelligence for agent fleets — AST-aware semantic search + multi-agent memory with git-concurrent coordination