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.
AbrirDo publicador
aivectormemory 是一款基于 Model Context Protocol (MCP) 开发的OpenClaw、OpenCode、ClaudeCodeAI记忆管理工具。它专门为 Claude、OpenCode、Cursor 和 主流IDE 编程工具设计,通过向量数据库技术解决 AI 在不同对话会话中「健忘」的问题。aivectormemory: A lightweight MCP Server enabling persistent, cross-session memory for AI-powered IDEs via vector search.
Still using CLAUDE.md / MEMORY.md as memory? This Markdown-file memory approach has fatal flaws: the file keeps growing, injecting everything into every session and burning massive tokens; content only supports keyword matching — search "database timeout" and you won't find "MySQL connection pool pitfall"; sharing one file across projects causes cross-contamination; there's no task tracking, so dev progress lives entirely in your head; not to mention the 200-line truncation, manual maintenance, and inability to deduplicate or merge.
AIVectorMemory is a fundamentally different approach. Local vector database storage with semantic search for precise recall (matches even when wording differs), on-demand retrieval that loads only relevant memories (token usage drops 50%+), automatic multi-project isolation with zero interference, and built-in issue tracking + task management that lets AI fully automate your dev workflow. All data is permanently stored on your machine — zero cloud dependency, never lost when switching sessions or IDEs.
┌─────────────────────────────────────────────────┐
│ AI IDE │
│ OpenCode / Codex / Claude Code / Cursor / ... │
└──────────────────────┬──────────────────────────┘
│ MCP Protocol (stdio)
┌──────────────────────▼──────────────────────────┐
│ AIVectorMemory Server │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │
│ │ remember │ │ recall │ │ auto_save │ │
│ │ forget │ │ task │ │ status/track │ │
│ └────┬─────┘ └────┬─────┘ └───────┬──────────┘ │
│ │ │ │ │
│ ┌────▼────────────▼───────────────▼──────────┐ │
│ │ Embedding Engine (ONNX) │ │
│ │ intfloat/multilingual-e5-small │ │
│ └────────────────────┬───────────────────────┘ │
│ │ │
│ ┌────────────────────▼───────────────────────┐ │
│ │ SQLite + sqlite-vec (Vector Index) │ │
│ │ ~/.aivectormemory/memory.db │ │
│ └────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────┘
# Install
pip install aivectormemory
# Upgrade to latest version
pip install --upgrade aivectormemory
# Navigate to your project directory, one-click IDE setup
cd /path/to/your/project
run install
run install interactively guides you to select your IDE, auto-generating MCP config, Steering rules, and Hooks — no manual setup needed.
macOS users note:
- If you get
externally-managed-environmenterror, add--break-system-packages- If you get
enable_load_extensionerror, your Python doesn't support SQLite extension loading (macOS built-in Python and python.org installers don't support it). Use Homebrew Python instead:brew install python /opt/homebrew/bin/python3 -m pip install aivectormemory
No pip install needed, run directly:
cd /path/to/your/project
uvx aivectormemory install
Requires uv to be installed.
uvxauto-downloads and runs the package — no manual installation needed.
{
"mcpServers": {
"aivectormemory": {
"command": "run",
"args": ["--project-dir", "/path/to/your/project"]
}
}
}
For Codex, use project-scoped TOML instead of JSON:
[mcp_servers.aivectormemory]
command = "run"
args = ["--project-dir", "/path/to/your/project"]
Codex only loads project-scoped
.codex/config.tomlafter the repository is marked as a trusted project.
remember — Store a memorycontent (string, required) Memory content in Markdown format
tags (string[], required) Tags, e.g. ["pitfall", "python"]
scope (string) "project" (default) / "user" (cross-project)
Similarity > 0.95 auto-updates existing memory, no duplicates.
recall — Semantic searchquery (string) Semantic search keywords
tags (string[]) Exact tag filter
scope (string) "project" / "user" / "all"
top_k (integer) Number of results, default 5
Vector similarity matching — finds related memories even with different wording.
forget — Delete memoriesmemory_id (string) Single ID
memory_ids (string[]) Batch IDs
status — Session statestate (object, optional) Omit to read, pass to update
is_blocked, block_reason, current_task,
next_step, progress[], recent_changes[], pending[]
Maintains work progress across sessions, auto-restores context in new sessions.
track — Issue trackingaction (string) "create" / "update" / "archive" / "list"
title (string) Issue title
issue_id (integer) Issue ID
status (string) "pending" / "in_progress" / "completed"
content (string) Investigation content
task — Task managementaction (string, required) "batch_create" / "update" / "list" / "delete" / "archive"
feature_id (string) Linked feature identifier (required for list)
tasks (array) Task list (batch_create, supports subtasks)
task_id (integer) Task ID (update)
status (string) "pending" / "in_progress" / "completed" / "skipped"
Links to spec docs via feature_id. Update auto-syncs tasks.md checkboxes and linked issue status.
readme — README generationaction (string) "generate" (default) / "diff" (compare differences)
lang (string) Language: en / zh-TW / ja / de / fr / es
sections (string[]) Specify sections: header / tools / deps
Auto-generates README content from TOOL_DEFINITIONS / pyproject.toml, multi-language support.
auto_save — Auto save preferencespreferences (string[]) User-expressed technical preferences (fixed scope=user, cross-project)
extra_tags (string[]) Additional tags
Auto-extracts and stores user preferences at end of each conversation, smart dedup.
graph — Code knowledge graphaction (string, required) "query" / "trace" / "batch" / "add_node" / "add_edge" / "remove" / "refresh"
name (string) Entity name (add_node/query)
entity_type (string) Entity type: function/class/module/api/table/config (add_node/query)
file_path (string) File path, auto-converts to relative (add_node/query/refresh)
source (string) Source node name or ID (add_edge)
target (string) Target node name or ID (add_edge)
relation (string) Relation type: calls/imports/inherits/uses/depends_on/contains (add_edge/trace)
start (string) Start node name or ID (trace)
direction (string) Traversal direction: "up" / "down" / "both" (trace)
max_depth (integer) Max traversal depth, default 3 (trace)
Manages function call chains, data flows, and dependency relationships. Trace upstream/downstream impact before code changes.
run web --port 9080
run web --port 9080 --quiet # Suppress request logs
run web --port 9080 --quiet --daemon # Run in background (macOS/Linux)
Visit http://localhost:9080 in your browser. Default username admin, password admin123 (can be changed in settings after first login).
AIVectorMemory is the storage layer. Use Steering rules to tell AI when and how to call these tools.
Running run install auto-generates Steering rules and Hooks config — no manual setup needed.
# AIVectorMemory - Workflow Rules
## 1. New Session Startup (execute in order)
1. `recall` (tags: ["project-knowledge"], scope: "project", top_k: 100) load project knowledge
2. `recall` (tags: ["preference"], scope: "user", top_k: 20) load user preferences
3. `status` (no state param) read session state
4. Blocked → report and wait; Not blocked → enter processing flow
## 2. Message Processing Flow
- Step A: `status` read state, wait if blocked
- Step B: Classify message type (chat/correction/preference/code issue)
- Step C: `track create` record issue
- Step D: Investigate (`recall` pitfalls + read code + find root cause)
- Step E: Present plan to user, set blocked awaiting confirmation
- Step F: Modify code (`recall` pitfalls before changes)
- Step G: Run tests to verify
- Step H: Set blocked awaiting user verification
- Step I: User confirms → `track archive` + clear block
## 3. Blocking Rules
Must `status({ is_blocked: true })` when proposing plans or awaiting verification.
Only clear after explicit user confirmation. Never self-clear.
## 4-9. Issue Tracking / Code Checks / Spec Task Mgmt / Memory Quality / Tool Reference / Dev Standards
(Full rules auto-generated by `run install`)
Auto-save on session end removed. Dev workflow check (.kiro/hooks/dev-workflow-check.kiro.hook):
{
"enabled": true,
"name": "Dev Workflow Check",
"version": "1",
"when": { "type": "promptSubmit" },
"then": {
"type": "askAgent",
"prompt": "Core principles: verify before acting, no blind testing, only mark done after tests pass"
}
}
The embedding model (~200MB) is auto-downloaded on first run. If slow:
export HF_ENDPOINT=https://hf-mirror.com
Or add env to MCP config:
{
"env": { "HF_ENDPOINT": "https://hf-mirror.com" }
}
Patch: Hard Constraints Against Opus 4.7 Default Tendencies
Patch: Full A-I Message Processing Flow Alignment
Patch: Rule Enforcement & Graph Visualization
Patch: i18n Rules Sync
graph tool references to all steering rules (trace/batch/add_node/add_edge/remove)New: Code Knowledge Graph
graph tool — manage function call chains, data flows, and dependency relationships as a structured knowledge graphtrace action — traverse upstream/downstream call chains from any entity, assess impact scope before code changesgraph_nodes and graph_edges tables for graph storageEnhancement: Rule System Overhaul + OpenClaw Support
open command workaroundEnhancement: AI Rule System Upgrade
New: Smart Memory Engine + Uninstall
run uninstall — cleanly removes all IDE configurations (MCP, steering, hooks, permissions) while preserving memory dataEnhancement: Security & Rule Optimization
New: Playwright Browser Testing Built-in
run install now automatically configures Playwright browser testing — AI can open a real browser to verify frontend changes instead of guessingEnhancement: More IDE Support
run install now auto-configures tool permissions, reducing manual setupEnhancement: Faster Startup
Enhancement: Simpler Rules
Fix: Tool Reliability
Enhancement: Better Search & Safety
Enhancement: Rule Generalization & Desktop Version Fix
Fix: Hook Cross-Project Compatibility
check_track.sh now derives project path from script location instead of $(pwd), fixing track detection failure when Claude Code runs hooks from non-root working directorycompact-recovery.sh now uses relative path derivation instead of hardcoded absolute paths, ensuring correct behavior when installed to any projectinstall.py template synchronized with all hook fixesPerformance: ONNX INT8 Quantization
New: Remember Password
Enhancement: Steering Rules
New: Native Desktop App
New: CI/CD Auto Build
Fixes
Optimization: Token Usage Reduction
New: Full-Stack i18n (7 Languages)
New: Web Dashboard Settings Page
Optimization: Memory Search
recall search supports OR/AND tag matching modes, fixing missed results with multi-tag searchesApache-2.0
aivectormemory 是一款基于 Model Context Protocol (MCP) 开发的OpenClaw、OpenCode、ClaudeCodeAI记忆管理工具。它专门为 Claude、OpenCode、Cursor 和 主流IDE 编程工具设计,通过向量数据库技术解决 AI 在不同对话会话中「健忘」的问题。aivectormemory: A lightweight MCP Se
Visão geral
aivectormemory 是一款基于 Model Context Protocol (MCP) 开发的OpenClaw、OpenCode、ClaudeCodeAI记忆管理工具。它专门为 Claude、OpenCode、Cursor 和 主流IDE 编程工具设计,通过向量数据库技术解决 AI 在不同对话会话中「健忘」的问题。aivectormemory: A lightweight MCP Server enabling persistent, cross-session memory for AI-powered IDEs via vector search.
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.
Aivectormemory roda localmente via stdio.
Última verificação: 2026-10-27. aivectormemory 是一款基于 Model Context Protocol (MCP) 开发的OpenClaw、OpenCode、ClaudeCodeAI记忆管理工具。它专门为 Claude、OpenCode、Cursor 和 主流IDE 编程工具设计,通过向量数据库技术解决 AI 在不同对话会话中「健忘」的问题。aivectormemory: A lightweight MCP Server enabling persistent, cross-session memory for AI-powered IDEs via vector search.