에이전트 강화
게시자의 자체 URL입니다. PlugMCP 엔드포인트가 아닙니다.
Host a copy with our keys and logs.
https://server.memwyre.tech/mcp/위의 Claude 버튼을 누르면 이름과 URL이 채워진 상태로 Claude가 열립니다. 확인은 Claude에서 직접 해야 합니다.
claude mcp add --transport http memwyreai-memwyre https://server.memwyre.tech/mcp/Run in a terminal.
{ "mcpServers": { "memwyreai-memwyre": { "command": "npx", "args": [ "-y", "mcp-remote", "https://server.memwyre.tech/mcp/" ] } }}claude_desktop_config.json
원격 URL인가요, 내 컴퓨터에서 실행하는 명령인가요? 두 설치 방식의 차이
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.
실행Memwyre is an open-source, universal memory infrastructure and persistent knowledge retrieval layer for Large Language Models (LLMs), AI agents, and custom applications.
Rather than treating AI as stateless and losing context every time you switch between ChatGPT, Claude, Cursor, or different agent environments, Memwyre sits externally as a unified personal brain. It securely ingests, chunks, and structures your documents, web pages, conversations, and workflows—making them instantly retrievable across your entire AI toolchain.
Build your own external memory layer using our consumer-facing dashboard or browser extension, and plug it directly into Cursor, VS Code, or Claude Desktop via MCP:
npx -y install-memwyre
Interface with the unified memory vault, custom vector searches, and profile-based retrieval APIs:
Memwyre provides multiple ways to ingest and retrieve information:
search_memory, save_memory, get_document) directly into IDEs like Cursor and VS Code, or desktop assistants like Claude Desktop.cli/) providing terminal-level interaction, query testing, and batch document uploads.openclaw-plugin/) allowing multi-agent platforms to interface directly with the Memwyre memory vault.Memwyre connects user clients to local or cloud vector search services and AI providers:
flowchart TB
subgraph Client_Side ["Client Side"]
Browser["WebApp (Vue 3 / Vite)"]
Extension["Chrome Extension (MV3)"]
CLI["CLI Client (Node.js)"]
end
subgraph Load_Balancer ["Ingress"]
Nginx["Nginx Reverse Proxy"]
end
subgraph Backend_Core ["Backend API (FastAPI)"]
Auth_Mod["Auth & Users Module"]
Mem_Mod["Memory Management"]
Ret_Mod["Retrieval Engine"]
LLM_Mod["LLM Service (V1/V2)"]
end
subgraph Background_Workers ["Celery Workers"]
Ingest_Worker["Ingestion & Chunking Worker"]
Dedupe_Worker["Deduplication Worker"]
end
subgraph Data_Persistence ["Data Layer"]
Postgres[("PostgreSQL / SQLite")]
Pinecone[("Pinecone / ChromaDB")]
Redis[("Redis Message Broker")]
end
subgraph External_Services ["AI Inference"]
NVIDIA["NVIDIA NIM (Kimi K2.6)"]
Azure["Azure OpenAI (GPT-4o-mini)"]
Gemini["Google Gemini API"]
end
Browser -->|HTTPS| Nginx
Extension -->|HTTPS| Nginx
CLI -->|HTTPS| Nginx
Nginx --> Backend_Core
Auth_Mod --> Postgres
Mem_Mod --> Postgres
Mem_Mod --> Ingest_Worker
Ret_Mod --> Pinecone
Ret_Mod --> Postgres
Ret_Mod --> External_Services
Ingest_Worker --> External_Services
Ingest_Worker --> Pinecone
Ingest_Worker --> Postgres
Ingesting a memory triggers background worker tasks to process, embed, and structure raw data asynchronously:
sequenceDiagram
participant User
participant API as FastAPI API
participant Worker as Celery Worker
participant LLM as LLM/Embedding Provider
participant Vector as Pinecone/ChromaDB
participant DB as PostgreSQL/SQLite
User->>API: POST /memory (Raw Text Content)
API->>DB: Save Memory (Status: Pending)
API->>Worker: Dispatch Ingest Task
API-->>User: 202 Accepted (In progress)
Note over Worker: Asynchronous Processing
Worker->>LLM: Metadata Extraction (Titles, Tags)
Worker->>Worker: Semantic Chunking (Overlapping Splits)
loop Parallel Enrichment
Worker->>LLM: Enrich Chunk (Q&A Pairs, Summaries)
Worker->>LLM: Extract SPO Facts (Subject-Predicate-Object)
end
Worker->>Vector: Batch Upsert Embeddings (Chunks + Facts)
Worker->>DB: Write Chunks & Facts (Linked to Memory)
Worker->>DB: Update Memory Status (Approved/Active)
Retrieval queries run exact relational Fact lookups and fuzzy Semantic Search in parallel to feed LLM contexts with ultra-low latency:
sequenceDiagram
participant User
participant API as FastAPI API
participant RetSvc as RetrievalService
participant Vector as Vector Store
participant DB as Relational DB
participant LLM as GenAI Model
User->>API: Chat Query / RAG Trigger
API->>RetSvc: search_memories(Query, project_id)
par State Fact Lookups
RetSvc->>Vector: Vector Search (Factual matches)
RetSvc->>DB: SQL Filter (Valid & Non-superseded Facts)
and Semantic Search
RetSvc->>Vector: Vector Search (Chunk embeddings)
RetSvc->>RetSvc: MMR Re-ranking (Filter redundant chunks)
end
RetSvc->>RetSvc: Merge Results (State Facts + Chunk text)
RetSvc-->>API: Ranked Top-K Context Items
API->>LLM: Generate Answer (Prompt + Merged Context)
LLM-->>User: Streaming Response
The LoCoMo-10 (Long Conversational Memory) benchmark, introduced by Snap Research in "Evaluating Very Long-Term Conversational Memory of LLM Agents" (2024), evaluates AI agent systems on long-term memory, factual consistency, temporal alignment, and multi-hop reasoning over lengthy, multi-session dialog flows (up to 32 sessions and 26,000 tokens per conversation).
[!TIP] Context Compression: Memwyre achieves a 88.5% context length reduction (retrieving 3,000 tokens instead of the 26,000-token raw conversational dialog) while significantly outperforming flat vector indexing in accuracy.
Memwyre uses a hybrid storage model: metadata, relational facts, and user credentials reside in SQL tables (PostgreSQL/SQLite), while document chunks and enriched fact strings are mirrored in vector databases (Pinecone/ChromaDB).
👉 View the Detailed Database Schema for a complete breakdown of the Core Entities (users, projects, memories, documents, chunks, facts) and the Entity Relationship Diagram.
subject and predicate is written (e.g. user moves from Berlin to Tokyo), the database marks the old record's is_superseded flag as true and updates valid_until to the current timestamp. This guarantees that temporal inquiries return state-accurate facts.project_id. When querying, filters strictly enforce containment matching the current workspace's project_id, preventing leakage across different project environments.Navigate to the backend directory, initialize the environment, install dependencies, and start the FastAPI server:
cd backend
# Create virtual environment and install packages
uv venv
uv pip install -r requirements.txt
# Start the FastAPI server
uv run uvicorn app.main:app --reload
API Swagger UI documentation will be available at http://localhost:8000/docs.
Ensure Redis is running, then start the Celery background worker to process ingestion queues:
cd backend
uv run celery -A app.celery_app worker --loglevel=info -P solo
Install frontend packages and spin up the Vite development server:
cd frontend
npm install
npm run dev
The web dashboard runs at http://localhost:5173.
chrome://extensions/extension/ folder from the root of this project.Add the following to your Claude Desktop config (located at %APPDATA%\Claude\claude_desktop_config.json on Windows or ~/Library/Application Support/Claude/claude_desktop_config.json on macOS):
{
"mcpServers": {
"brain-vault": {
"command": "python",
"args": ["/path/to/memwyre/backend/mcp_server.py"]
}
}
}
Configure your editor's MCP settings to run the server via command line:
python /path/to/memwyre/backend/mcp_server.py
Install dependencies and run the command line tool globally:
cd cli
npm install
node index.js --help
Copy the example environment file in the backend/ directory and configure the variables:
cp backend/.env.example backend/.env
Key environment parameters:
# --- Base Secrets & Database ---
SECRET_KEY="your-strong-random-64-character-string"
DATABASE_URL="postgresql://postgres:password@localhost/brain-vault"
# --- Redis & Celery ---
CELERY_BROKER_URL="redis://localhost:6379/0"
REDIS_URL="redis://localhost:6379/0"
# --- Vector Database (Pinecone) ---
PINECONE_API_KEY="your-pinecone-api-key"
PINECONE_HOST="https://your-pinecone-index-host"
PINECONE_SPARSE_HOST="https://your-optional-sparse-index-host"
# --- LLM Providers & Embeddings ---
MEMORY_ENGINE_VERSION="v2" # "v1" for NVIDIA, "v2" for Azure/OpenAI
AZURE_OPENAI_API_KEY="your-azure-key"
AZURE_OPENAI_ENDPOINT="https://your-resource-name.cognitiveservices.azure.com/"
AZURE_OPENAI_DEPLOYMENT="gpt-4o-mini"
AZURE_OPENAI_EMBEDDING_DEPLOYMENT="text-embedding-3-small"
# --- V1 Compatibility (NVIDIA NIM) ---
EMBEDDING_API_KEY="your-nvidia-embedding-key"
LLM_API_KEY="your-nvidia-llm-key"
This project is licensed under the Apache License, Version 2.0 (Apache-2.0). See the LICENSE and NOTICE files for details.
Memwyre is an open-source, universal memory infrastructure and persistent knowledge retrieval layer for Large Language Models (LLMs), AI agents, and custom applications.
{ "mcpServers": { "memwyreai-memwyre": { "url": "https://server.memwyre.tech/mcp/", "headers": {} } }}도구
아직 도구 목록이 없습니다. 원격 서버는 첫 상태 확인 후에 도구 목록이 생깁니다.
FAQ
이 페이지에서 Cursor, Claude Desktop, Claude Code 또는 VS Code용 http 설정을 복사합니다. PlugMCP 프록시가 아니라 게시자의 설치 방식을 사용합니다.
이 레코드에는 필수 환경 변수가 등록되어 있지 않습니다.
Memwyre에는 HTTP로 연결합니다.
마지막 확인: 2026-10-28. Memwyre is an open-source, universal memory infrastructure and persistent knowledge retrieval layer for Large Language Models (LLMs), AI agents, and custom applications.