# What Are the Four Core Services of TencentDB Agent Memory?

> Explore the four core services of TencentDB Agent Memory: MemoryCore, MemoryPanel, MemoryKnowledge, and MemoryProxy. Discover how these integrated services form a complete team memory platform for LLM agents.

- Repository: [Tencent Cloud/TencentDB-Agent-Memory](https://github.com/TencentCloud/TencentDB-Agent-Memory)
- Tags: deep-dive
- Published: 2026-09-04

---

**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/main/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/main/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/main/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/main/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:

```bash
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:

```bash
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:

```javascript
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:

```bash
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`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/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).