How to Generate a Skill Listing for Prompt Injection with TencentDB Agent Memory

Use the POST /v3/skill/listing endpoint via SkillClient.listing() to retrieve a markdown-formatted skill catalog that you can inject into LLM prompts, respecting team and agent isolation boundaries.

The TencentDB Agent Memory SDK provides a specialized interface for generating skill listings that enable dynamic prompt injection in LLM applications. When building agent systems, you need to inform the model about available tools without hardcoding descriptions or maintaining manual documentation. This guide demonstrates how to generate a skill listing for prompt injection using the official Python SDK, leveraging isolation defaults and character budgeting to optimize token usage for downstream models.

Understanding the Skill Listing Endpoint

The skill listing endpoint (POST /v3/skill/listing) generates the <available_skills> block that can be injected into prompts to give LLMs a catalog of invocable skills. According to the TencentDB-Agent-Memory source code, the system combines isolation defaults with runtime parameters to ensure secure, context-aware skill visibility.

The endpoint accepts two primary parameters:

• query – Optional string to filter skills by name or description
• char_budget – Integer limiting the rendered markdown block size to prevent token overflow

The server returns a JSON payload containing a listing field with pre-formatted markdown. This block respects the same isolation rules (team, agent, user boundaries) used throughout the memory system, ensuring you only expose skills authorized for the current execution context.

Generating Skill Listings with the SDK

The SDK implements this functionality in SkillClient.listing for synchronous operations and AsyncSkillClient.listing for asynchronous workflows. Both methods follow the same parameter signature but differ in their execution model.

Synchronous Usage

Initialize the client with your endpoint credentials and isolation defaults, then call listing() to retrieve the markdown block:

from tencentdb_agent_memory.v3 import SkillClient

# Initialise the client with credentials and default isolation IDs

skills = SkillClient(
    endpoint="https://memory.tencentyun.com",
    api_key="sk-…",               # Keep this secret

    service_id="mem-abc",
    team_id="team-1",
    agent_id="agent-coder",
    user_id="user-42"
)

# Generate a listing – limit to 1500 characters and filter by keyword

resp = skills.listing(query="code", char_budget=1500)

# The rendered markdown block ready for prompt injection

skill_listing_md = resp.get("listing", "")
print("=== Skill Listing ===")
print(skill_listing_md)

Setting query="code" narrows results to skills matching that term, while char_budget=1500 caps the output size to conserve context window space in downstream LLM APIs.

Asynchronous Usage

For high-throughput applications, use AsyncSkillClient with identical parameters:

import asyncio
from tencentdb_agent_memory.v3 import AsyncSkillClient

async def make_listing():
    async with AsyncSkillClient(
        endpoint="https://memory.tencentyun.com",
        api_key="sk-…",
        service_id="mem-abc",
        team_id="team-1",
        agent_id="agent-coder",
        user_id="user-42"
    ) as skills:
        resp = await skills.listing(char_budget=2000)   # No query → full list

        return resp.get("listing", "")

listing_md = asyncio.run(make_listing())
print(listing_md)

The async client mirrors the synchronous API exactly, ensuring consistent behavior across both execution models.

Injecting Skills into LLM Prompts

Once you generate the skill listing, concatenate it with your user message to create an augmented prompt:

def build_prompt(user_message: str, skill_listing: str) -> str:
    # Concatenate listing before user message to establish available tools

    return f"{skill_listing}\nUser: {user_message}\nAssistant:"

# Example usage

user_msg = "How can I refactor this Python function?"
prompt = build_prompt(user_msg, skill_listing_md)

# Send `prompt` to your LLM provider (OpenAI, Claude, etc.)

Placing the skill listing at the beginning of the prompt establishes the tool context before the user query, helping the model recognize when to invoke specific skills during response generation.

Implementation Details in the Source Code

The SDK handles several critical operations before sending requests to the /v3/skill/listing endpoint. In /sdk/memory-core/python/tencentdb_agent_memory/v3/skill_client.py, the listing method (lines 514-531) performs three key steps:

1. Merging isolation defaults – The _SkillDefaults.merge method (lines 85-115) combines team, agent, and user IDs supplied at client construction with any per-call overrides, ensuring consistent security boundaries.

2. Stripping empty values – The _strip_none helper (lines 57-59) removes None entries from the request payload before serialization, preventing invalid JSON from reaching the server.

3. POST construction – The method assembles the final request body containing the optional query and char_budget parameters, then transmits via the internal HTTP stub to https://memory.tencentyun.com/v3/skill/listing.

These implementation details ensure that your skill listings respect the same visibility permissions enforced by the memory system's server-side logic.

Summary

• The POST /v3/skill/listing endpoint generates markdown-formatted skill catalogs designed specifically for prompt injection scenarios.
• Both SkillClient.listing() and AsyncSkillClient.listing() support query filtering and char_budget limits to optimize token usage.
• Isolation defaults (team_id, agent_id, user_id) set during client initialization automatically propagate to listing requests, ensuring secure skill visibility.
• The response's listing field contains ready-to-inject markdown that you can concatenate with user messages before sending to LLM providers.
• Source code in skill_client.py handles parameter merging and sanitization through _SkillDefaults.merge and _strip_none helpers.

Frequently Asked Questions

What is the maximum character budget for a skill listing?

The char_budget parameter accepts any positive integer value, but you should align it with your target LLM's context window limitations. For GPT-4-class models, budgets between 1500-4000 characters typically leave sufficient room for user queries and response generation while providing comprehensive skill descriptions.

How does skill isolation work in the listing endpoint?

The SDK automatically applies isolation rules defined during client initialization. As implemented in skill_client.py lines 85-115, the _SkillDefaults.merge method combines team_id, agent_id, and user_id values, ensuring the server only returns skills visible within those specific boundaries. This prevents cross-contamination of tools between different teams or user sessions.

Can I filter skills by category when generating a listing?

Yes, use the query parameter to filter skills by name or description keywords. While the SDK does not expose explicit category filters, semantic matching in the backend processes natural language queries to return relevant subsets of your skill registry.

Is the async client implementation identical to the sync version?

Functionally yes. AsyncSkillClient.listing() accepts identical parameters and returns the same response structure as SkillClient.listing(). The implementation differs only in using async with context managers and await syntax for non-blocking I/O operations, as shown in the source code's parallel method definitions.

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