What Are the Four Core Services of TencentDB Agent Memory?

The four core services of TencentDB Agent Memory are MemoryCore, MemoryPanel, MemoryKnowledge, and MemoryProxy—four independent yet tightly-integrated services that together provide a complete "team memory" platform for LLM agents.

TencentDB Agent Memory is an open-source framework maintained by Tencent Cloud that enables persistent, shared memory across AI agent teams. Understanding the four core services of TencentDB Agent Memory is essential for building production-grade agent systems, as each component handles a distinct layer of the memory stack from raw data persistence to human oversight.

The Four Core Services Defined

According to the architecture documentation in the Tencent Cloud repository, the platform separates concerns into four specialized services:

• MemoryCore – The persistence kernel that stores, queries, and processes all memory assets.
• MemoryKnowledge – The graph-oriented knowledge service that powers RAG retrieval over Wiki and CodeGraph data.
• MemoryProxy – A transparent LLM request proxy that automatically injects memory into model calls.
• MemoryPanel – A web-based control plane for humans to manage teams, permissions, and asset curation.

These services communicate via HTTP APIs and form a layered architecture where MemoryCore sits at the data plane, MemoryKnowledge provides structured views, MemoryProxy bridges external LLMs, and MemoryPanel offers the management interface.

MemoryCore: The Persistent Storage Layer

MemoryCore serves as the foundational memory kernel documented in [MemoryCore/v3-api-memorycore-doc.md](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/feat/server_team/MemoryCore/v3-api-memorycore-doc.md). It handles the full lifecycle of Chat Memory, Skills, Wiki, and CodeGraph data across the L0-L3 memory layers.

The service exposes a REST API on http://<host>:8420/v3/* and uses Redis and SQLite backends for durability and performance. All raw asset storage—whether short-term conversation buffers or long-term skill definitions—flows through this component. When agents write memory or retrieve historical context, they interact with MemoryCore’s /v3/skill/conversation/add and related endpoints.

MemoryKnowledge: Graph-Based RAG Retrieval

Built on top of MemoryCore, MemoryKnowledge specializes in structured knowledge retrieval. As detailed in [MemoryKnowledge/v3-api-memoryknowledge-doc.md](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/feat/server_team/MemoryKnowledge/v3-api-memoryknowledge-doc.md), this service exposes /v3/wiki and /v3/code-graph endpoints that transform raw storage into graph-aware representations for RAG-enabled applications.

Unlike the raw storage layer, MemoryKnowledge adds semantic linking and metadata indexing, allowing agents to query documentation and code symbols via the /v3/wiki/search endpoint. This service runs on the same host port as MemoryCore (8420) but handles distinct route prefixes for knowledge-specific operations.

MemoryProxy: Zero-Code LLM Integration

MemoryProxy acts as a transparent intermediary between LLM clients and the memory stack. Documented in [MemoryProxy/v3-api-memoryproxy-doc.md](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/feat/server_team/MemoryProxy/v3-api-memoryproxy-doc.md), this service wraps any LLM implementation—whether Claude Code, CodeBuddy, or DeepSeek—so that agents read and write memory without source code modifications.

The proxy listens on http://<host>:8360/<spaceId>/... and implements six primary operation types under its /v3/* interface. It handles authentication, session initialization via the x-tdai-user-key header, and automatic conversation write-back to MemoryCore, making it a stateless bridge that injects context into LLM requests.

MemoryPanel: Human-in-the-Loop Management

The MemoryPanel service provides the administrative interface for the platform. According to [MemoryPanel/panel-api-doc.md](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/feat/server_team/MemoryPanel/panel-api-doc.md), this web-based UI runs on port 8125 and enables team creation, asset review, ACL configuration, and permission management.

Unlike the other three services, MemoryPanel persists UI state—such as team definitions and access control lists—and propagates these configurations to Core and Knowledge via internal API calls. It serves as the only human-facing component in the four-service architecture.

Running the Complete Stack

To launch all four services locally, clone the repository and use the provided deployment scripts:

git clone https://github.com/TencentCloud/TencentDB-Agent-Memory.git
cd TencentDB-Agent-Memory/deploy/global-images
cp .env.example .env          # Configure your LLM credentials

./start-all.sh                # Launches MemoryCore, MemoryPanel, and MemoryProxy

Once running, the services bind to their default ports: 8420 for MemoryCore (and MemoryKnowledge), 8125 for MemoryPanel, and 8360 for MemoryProxy.

Querying Knowledge via MemoryKnowledge

To retrieve structured Wiki entries using the Knowledge service:

curl -X POST http://127.0.0.1:8420/v3/wiki/search \
  -H 'Content-Type: application/json' \
  -d '{"query":"authentication flow"}'

Injecting Skills via MemoryProxy

The following Node.js example demonstrates how MemoryProxy forwards skill execution to MemoryCore without modifying the LLM client:

import fetch from 'node-fetch';

const proxyBase = 'http://127.0.0.1:8360/proxy/demo';
const skillEndpoint = `${proxyBase}/skill-bridge/v3/skill/conversation/add`;

await fetch(skillEndpoint, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-tdai-user-key': 'YOUR_USER_KEY',   // Retrieved from MemoryPanel
  },
  body: JSON.stringify({
    conversationId: 'conv-123',
    messages: [{ role: 'assistant', content: 'Hello!' }],
  }),
});

Managing Teams via MemoryPanel

To create a new team through the administrative interface:

curl -X POST http://127.0.0.1:8125/api/teams \
  -H 'Authorization: Bearer ADMIN_TOKEN' \
  -d '{"name":"Acme Corp","description":"Demo team"}'

Summary

• MemoryCore provides the durable storage backend for all memory assets via port 8420, handling Chat Memory, Skills, Wiki, and CodeGraph data.
• MemoryKnowledge extends Core with graph-based retrieval capabilities for RAG applications, exposing specialized endpoints under /v3/wiki and /v3/code-graph.
• MemoryProxy offers transparent LLM integration on port 8360, automatically injecting memory context into agent conversations without code changes.
• MemoryPanel delivers the human management interface on port 8125, controlling teams, permissions, and asset curation through a web UI.

Frequently Asked Questions

What is the difference between MemoryCore and MemoryKnowledge?

MemoryCore handles raw persistence and lifecycle management of all memory types, while MemoryKnowledge specifically processes and serves structured Wiki and CodeGraph data for retrieval-augmented generation (RAG). Knowledge reads from Core but adds semantic indexing and graph relationships that Core does not maintain.

Which port does each of the four services use?

According to the source documentation, MemoryCore and MemoryKnowledge share port 8420 (with Knowledge using /v3/wiki and /v3/code-graph routes), MemoryPanel uses port 8125, and MemoryProxy listens on port 8360.

How does MemoryProxy inject memory without requiring code changes?

MemoryProxy operates as a transparent HTTP intermediary that intercepts LLM requests, validates the x-tdai-user-key header against MemoryPanel’s ACLs, and automatically appends relevant context from MemoryCore before forwarding the request to the destination LLM. Agents simply point their API calls at the proxy URL instead of the direct LLM endpoint.

Can the four services run independently or must they be co-located?

While the start-all.sh script launches the services together, each component is designed as an independent microservice. MemoryProxy and MemoryPanel communicate with MemoryCore via HTTP, allowing horizontal scaling and distributed deployment, provided network connectivity exists between the ports (8420, 8125, and 8360).

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}