# How MemoryPanel Enables Team Management in TencentDB Agent Memory

> Discover how MemoryPanel streamlines team management in TencentDB Agent Memory. Create teams, orchestrate agents, and govern memory assets with its centralized UI and REST endpoints.

- Repository: [Tencent Cloud/TencentDB-Agent-Memory](https://github.com/TencentCloud/TencentDB-Agent-Memory)
- Tags: how-to-guide
- Published: 2026-08-24

---

**The MemoryPanel serves as a stateless management console that provides centralized REST endpoints and a React-based UI for creating teams, orchestrating agents, and governing memory assets across the TencentDB Agent Memory ecosystem.**

The **TencentDB Agent Memory** repository by TencentCloud introduces a sophisticated control plane called the **MemoryPanel** to simplify team management in AI-assisted workflows. This component acts as a stateless gateway that abstracts the complexity of the underlying Memory Gateway and Knowledge Service. By exposing unified administrative interfaces, MemoryPanel enables organizations to provision teams, manage API keys, and orchestrate agent tasks without maintaining local session state.

## Stateless Architecture for Scalable Team Management

### Configuration-Driven Deployment

At startup, the panel reads [`config/metadata-instances.json`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/config/metadata-instances.json) (mounted read-only) to discover external service URLs and privileged internal credentials. This design eliminates the need for a local database or session store, allowing the panel to run behind any load balancer. As implemented in [`src/panel/startup/ensure-knowledge-llm-binding.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/startup/ensure-knowledge-llm-binding.ts), all persistence is delegated to the backing services, making horizontal scaling trivial.

### Authentication and Identity Mapping

Every incoming request must carry a `user_key` header containing a per-user API key. The validation logic in [`src/panel/config/panel-config.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/config/panel-config.ts) verifies these keys and maps them to team-level identities (`x-team-id`, `x-agent-id`, `x-task-id`). Because keys are validated on every request and never persisted server-side, the system maintains strict statelessness while enforcing security boundaries.

## Administrative Control and Asset Orchestration

### Team and User Lifecycle Management

The panel exposes REST endpoints under `/api/v1/meta/*` for provisioning teams and managing membership. The route handlers in [`src/panel/http/routes/meta/instances.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/http/routes/meta/instances.ts) implement CRUD operations for team definitions, user assignments, and API key issuance. These endpoints allow administrators to create isolated organizational units and assign granular permissions without modifying underlying infrastructure.

### Centralized Asset Registration

Through kernel adapters like those found in [`src/panel/kernel/adapters/http-knowledge-client.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/kernel/adapters/http-knowledge-client.ts) and [`src/panel/kernel/adapters/fetch-meta-kernel-adapter.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/kernel/adapters/fetch-meta-kernel-adapter.ts), the panel translates generic API calls into specific Memory Gateway or Knowledge Service requests. It exposes unified routes for **Skill**, **Wiki**, **Code-Graph**, and **Chat-Memory** assets (`/api/v1/skill/*`, `/api/v1/knowledge/*`, `/api/v1/chat-memory/*`), enabling teams to register and bind resources to specific agents and tasks.

## Governance and Policy Enforcement

### Domain-Level Validation Logic

The [`src/panel/domain/chat-memory-governance.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/domain/chat-memory-governance.ts) file contains the core logic for enforcing team-level policies, such as restricting task access to owned assets and limiting chat-memory snapshot sizes. This domain layer operates independently of transport concerns, ensuring consistent policy application whether requests originate from the React frontend or direct API calls.

### Observability and Health Monitoring

Operational visibility comes through structured logging in [`src/panel/infra/logger.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/infra/logger.ts) and a dedicated health endpoint (`GET /health`). These mechanisms support CI/CD pipelines and production monitoring, providing teams with real-time insights into panel performance and service connectivity.

## Practical Implementation Examples

### Creating Teams and Agents via REST API

To provision a new team, operators send an authenticated POST request to the metadata endpoint:

```bash
curl -X POST http://localhost:8123/api/v1/meta/teams \
  -H "Authorization: Bearer <USER_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
        "name": "Demo Team",
        "description": "Team for testing the Memory Panel"
      }'

```

After team creation, register an agent using the Node SDK:

```typescript
import { MemoryCoreClient } from '@tencentdb/memory-core';

const client = new MemoryCoreClient({
  baseURL: 'http://localhost:8123/api/v1',
  headers: { Authorization: `Bearer ${USER_KEY}` },
});

await client.post('/agent', {
  teamId: '<TEAM_ID>',
  name: 'demo-agent',
  description: 'Agent used for demo tasks',
});

```

### Binding Skills and Retrieving Overviews

Teams can bind Skills to Tasks through the frontend or API. The React frontend in [`web/src/pages/workbench/WorkbenchPage/index.tsx`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/web/src/pages/workbench/WorkbenchPage/index.tsx) manages these relationships via internal stores:

```tsx
import { useTaskStore } from '@/services/task-store';

const bindSkill = async (skillId: string, taskId: string) => {
  await useTaskStore().addSkill(taskId, skillId);
};

```

To retrieve aggregated agent metadata across all asset types:

```typescript
import axios from 'axios';

async function getAgentOverview(agentId: string) {
  const res = await axios.get(
    `http://localhost:8123/api/v1/agent-overview/${agentId}`,
    { headers: { Authorization: `Bearer ${USER_KEY}` } }
  );
  return res.data; // contains agent metadata, linked skills, wiki, chat-memory stats
}

```

## Critical Source Files for Team Management

The following files define the core functionality that enables MemoryPanel's team management capabilities:

- **[`src/panel/index.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/index.ts)** – Entry point that initializes the Hono server and registers route middleware.
- **[`src/panel/config/panel-config.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/config/panel-config.ts)** – Loads [`metadata-instances.json`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/metadata-instances.json) and provides external service clients.
- **[`src/panel/http/routes/meta/instances.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/http/routes/meta/instances.ts)** – Implements REST endpoints for teams, users, agents, and tasks.
- **[`src/panel/domain/chat-memory-governance.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/domain/chat-memory-governance.ts)** – Enforces team-level policies and asset governance rules.
- **[`src/panel/kernel/adapters/fetch-meta-kernel-adapter.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/kernel/adapters/fetch-meta-kernel-adapter.ts)** – Translates panel API calls to Memory Gateway requests.
- **[`src/panel/kernel/adapters/http-knowledge-client.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/kernel/adapters/http-knowledge-client.ts)** – Handles communication with the Knowledge Service.
- **[`web/src/pages/workbench/WorkbenchPage/index.tsx`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/web/src/pages/workbench/WorkbenchPage/index.tsx)** – React dashboard for visual team and asset management.
- **[`docs/api/meta-api.openapi.yaml`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/docs/api/meta-api.openapi.yaml)** – OpenAPI contract defining the panel's external interface.

## Summary

- **MemoryPanel** provides a **stateless control plane** for TencentDB Agent Memory, eliminating session affinity concerns and enabling horizontal scaling.
- Team management features include **user provisioning**, **API key issuance**, and **agent/task orchestration** through REST endpoints in [`src/panel/http/routes/meta/instances.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/http/routes/meta/instances.ts).
- The **kernel adapter pattern** abstracts underlying services, presenting a unified interface for Skill, Wiki, Code-Graph, and Chat-Memory asset management.
- **Domain-level governance** in [`src/panel/domain/chat-memory-governance.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/domain/chat-memory-governance.ts) enforces team isolation and resource limits without coupling to transport layers.
- Configuration-driven deployment via [`metadata-instances.json`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/metadata-instances.json) ensures that no local state persists, allowing seamless replication and load-balanced deployments.

## Frequently Asked Questions

### What is the primary function of MemoryPanel in TencentDB Agent Memory?

The MemoryPanel serves as the administrative control layer that sits between operators and the core memory services. It provides both a REST API and a React-based UI for creating teams, managing users, and orchestrating AI agents while remaining completely stateless to support scalable deployments.

### How does MemoryPanel authenticate requests without maintaining session state?

The panel validates a `user_key` header on every incoming request using logic defined in [`src/panel/config/panel-config.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/config/panel-config.ts). It maps these keys to team and agent identities without persisting session data server-side, relying instead on external service validation and header-based identity propagation.

### Can multiple instances of MemoryPanel run simultaneously for high availability?

Yes. Because the panel stores no local user sessions or databases—all persistence is delegated to external services via [`metadata-instances.json`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/metadata-instances.json) configuration—you can deploy any number of replicas behind a load balancer without configuring sticky sessions or shared state between instances.

### How does the system prevent teams from accessing each other's assets?

Policy enforcement occurs in the domain layer, specifically within [`src/panel/domain/chat-memory-governance.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/src/panel/domain/chat-memory-governance.ts). This module validates that tasks can only access assets owned by their respective teams and enforces size limits on chat-memory snapshots, ensuring strict isolation between organizational units.