# How to Execute a Wiki Search Tool in TencentDB Agent Memory

> Learn to execute a Wiki search tool in TencentDB Agent Memory. Discover available tools and invoke wiki-search via API calls for efficient data retrieval.

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

---

**To execute a Wiki search tool in the TencentDB Agent Memory platform, first discover available tools via the `GET /v3/tools/list` endpoint, then invoke the `wiki-search` tool by sending a `POST` request to `/v3/tools/call` with your query and metadata payload.**

The TencentDB Agent Memory repository exposes Wiki search functionality through a standardized tool interface defined in the Knowledge Service (MemoryKnowledge). This architecture allows agents to dynamically discover and execute search capabilities against indexed Wiki assets without hardcoding endpoint URLs.

## Architecture and Source Code Locations

The Wiki search tool implementation spans multiple components in the `TencentCloud/TencentDB-Agent-Memory` repository (specifically the `feat/server_team` branch):

- **[`MemoryKnowledge/src/routes/tools.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryKnowledge/src/routes/tools.ts)**: Implements the generic `/v3/tools/list` and `/v3/tools/call` HTTP endpoints. This file contains the routing logic that dispatches tool calls to concrete handlers.

- **[`MemoryKnowledge/src/routes/wiki.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryKnowledge/src/routes/wiki.ts)**: Houses the Wiki Service logic that manages Wiki objects and executes the actual search query against the indexed content.

- **[`MemoryProxy/src/injection/injectors/knowledge-tools-injector.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/injectors/knowledge-tools-injector.ts)**: Registers the `wiki-search` tool definition during service initialization, ensuring it appears in the discovery response.

- **[`MemoryPanel/web/src/lib/api/knowledge-api.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryPanel/web/src/lib/api/knowledge-api.ts)**: Provides a TypeScript wrapper used by the frontend to call the tool endpoints.

## Execution Workflow

### Step 1 – Discover the Tool

Before execution, retrieve the tool descriptor to confirm availability and required parameters:

```bash
curl -s https://ks.example.com/v3/tools/list

```

The response includes a JSON object describing the Wiki search capability:

```json
{
  "name": "wiki-search",
  "description": "Search Wiki pages by keyword",
  "input_schema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" }
    },
    "required": ["query"]
  }
}

```

### Step 2 – Call the Tool

Send a `POST` request to `/v3/tools/call` with the tool name, input payload, and contextual metadata:

```bash
curl -s -X POST https://ks.example.com/v3/tools/call \
  -H "Content-Type: application/json" \
  -d '{
    "tool_name": "wiki-search",
    "input": { "query": "memory architecture" },
    "metadata": { "team_id": "team-1", "user_id": "user-123" }
  }'

```

The `tool_name` must match the identifier from the discovery step. The `input` object follows the schema defined in the tool descriptor, while `metadata` provides session context required by the Knowledge Service.

### Step 3 – Handle the Response

The Knowledge Service returns a standardized envelopeformat regardless of internal success or failure:

```json
{
  "code": 0,
  "message": "ok",
  "data": {
    "results": [
      {
        "title": "Memory Architecture Overview",
        "url": "/wiki/memory-architecture",
        "snippet": "Detailed explanation of agent memory systems...",
        "page_id": "page-456"
      }
    ]
  }
}

```

If the search fails, the `data.isError` flag is set to `true` and `data.text` contains the error description, even when the HTTP status code is `200`.

## Implementation Examples

### Using the TypeScript Frontend Wrapper

The project provides a dedicated API module for tool execution:

```typescript
import { knowledgeApi } from '@/lib/api/knowledge-api';

// Step 1: Discover
const tools = await knowledgeApi.toolsList();
const wikiTool = tools.find(t => t.name === 'wiki-search');
if (!wikiTool) throw new Error('Wiki search tool not available');

// Step 2: Execute
const result = await knowledgeApi.toolsCall({
  tool_name: wikiTool.name,
  input: { query: 'agent memory patterns' },
  metadata: { team_id: 'team-1', user_id: 'u123' }
});

// Step 3: Process results
if (result.isError) {
  console.error('Search failed:', result.text);
} else {
  console.log('Found pages:', result.data);
}

```

### Using Python

```python
from memory_core import KnowledgeClient

kc = KnowledgeClient(service_url="http://ks:8421/v3")

# Discover tools

tools = kc.tools_list()
wiki_tool = next(t for t in tools if t["name"] == "wiki-search")

# Execute Wiki search tool

resp = kc.tools_call(
    tool_name=wiki_tool["name"],
    input={"query": "LLM context window"},
    metadata={"team_id": "team-1", "user_id": "u42"}
)

# Check response envelope

if resp["data"]["isError"]:
    print(f"Error: {resp['data']['text']}")
else:
    for page in resp["data"]["results"]:
        print(f"{page['title']}: {page['url']}")

```

## Error Handling Behavior

The Knowledge Service maintains a consistent response contract even when internal errors occur. Always inspect `data.isError` rather than relying solely on HTTP status codes. According to the implementation in [`MemoryKnowledge/src/routes/tools.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryKnowledge/src/routes/tools.ts), a system failure returns HTTP 500 with an envelope where `data.isError` is `true`, allowing clients to handle failures uniformly without parsing different response structures.

## Summary

- **Two-step process**: Execute a Wiki search tool by first calling `/v3/tools/list` for discovery, then `/v3/tools/call` for invocation.
- **Required parameters**: Include `tool_name` (`wiki-search`), `input` (containing the `query` string), and `metadata` (with `team_id` and `user_id`).
- **Source locations**: Tool routing resides in [`MemoryKnowledge/src/routes/tools.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryKnowledge/src/routes/tools.ts) and search logic in [`MemoryKnowledge/src/routes/wiki.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryKnowledge/src/routes/wiki.ts).
- **Response format**: All results return in a standardized envelope with `code`, `message`, and `data` fields; check `data.isError` for application-level failures.
- **Multi-language support**: Available via raw HTTP, TypeScript wrappers in `MemoryPanel`, or Python SDK with identical JSON schemas.

## Frequently Asked Questions

### What endpoints are required to execute a Wiki search tool?

You must use `GET /v3/tools/list` to retrieve the tool schema and confirm availability, followed by `POST /v3/tools/call` to submit your search query. Both endpoints are implemented in [`MemoryKnowledge/src/routes/tools.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryKnowledge/src/routes/tools.ts).

### Where is the Wiki search logic implemented in the codebase?

The tool call routing and endpoint definitions are in [`MemoryKnowledge/src/routes/tools.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryKnowledge/src/routes/tools.ts), while the actual search execution against the Wiki index occurs in [`MemoryKnowledge/src/routes/wiki.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryKnowledge/src/routes/wiki.ts). The tool registration happens in [`MemoryProxy/src/injection/injectors/knowledge-tools-injector.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/injectors/knowledge-tools-injector.ts).

### How do I handle errors when calling the Wiki search tool?

Check the `data.isError` boolean field in the response envelope. Unlike standard REST APIs that rely on HTTP status codes, this platform returns HTTP 200 with `data.isError: true` when the tool execution fails internally, providing error details in `data.text`.

### Can I execute the Wiki search tool without using the frontend wrapper?

Yes. While [`MemoryPanel/web/src/lib/api/knowledge-api.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryPanel/web/src/lib/api/knowledge-api.ts) provides a convenient TypeScript abstraction, you can execute the tool using any HTTP client (cURL, Python `requests`, etc.) by directly calling the `/v3/tools/call` endpoint with the proper JSON payload structure.