# Tencent Yuanqi MCP

> Tencent Yuanqi MCP Server manages specialized AI agents and knowledge bases. Use this server to chat with published assistants, upload documents for RAG context, monitor API usage, or check file processing status directly from your agent framework.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** tencent, yuanqi, ai-agents, rag-knowledge-base, hunyuan-model

## Description

This MCP connects your AI client directly to **Tencent Yuanqi**, giving you nine specific tools to manage specialized agents and handle knowledge documents. You're talking to an intelligent agent platform powered by the Hunyuan model, and these tools let you control everything from conversation context to raw data lifecycle.

To interact with published assistants, you use `chat`; this sends a message to a specific Tencent Yuanqi assistant ID and immediately returns the conversational response. If you're building complex flows that require tracking history, it handles those persistent context sessions for you.

When you need to manage your knowledge base—the stuff your agents read from—you first use `upload_file` to send a document to the Yuanqi platform; this gets the file processed and ready for agent consumption. Once uploaded, you can list all stored documents using `list_files`, which outputs an inventory of everything currently in your knowledge base. If that document needs to be removed later, you use `delete_file` to take it out.

Since agents need context before they're useful, you often have to wait for the uploaded files to get indexed. That's where `get_file_status` comes in; it checks if a document is finished being processed and ready for actual RAG use. You also can check basic file details—like its name or size—by calling `get_file_info`.

To manage the agents themselves, you first get an overview of what's available by running `list_assistants`, which retrieves a full list of every assistant you've created in your account. For deeper technical dives, `get_assistant_info` pulls detailed metadata and configuration settings for any specific assistant ID. This gives you granular control over how those agents function.

Lastly, when you're running these tools frequently, you gotta watch the billing. The `get_usage` tool returns a clear report showing your API token consumption and what quota limits you still have remaining. You can also check the system status by retrieving detailed metadata about any specific assistant ID using `get_assistant_info`. These tools let you control the entire document lifecycle—uploading, listing, deleting, checking status, and getting basic file info—while also letting you chat with agents, list all available agents, and track your usage right from your agent framework. You're running a tight operation here; this server makes sure every step of the way is accounted for.

## Tools

### chat
Sends a message to a specific Tencent Yuanqi assistant ID and receives the conversational response.

### get_file_status
Checks the current processing status of an uploaded file to see if it's ready for use in RAG.

### list_files
Outputs a list of all documents currently stored and managed within your knowledge base.

### upload_file
Sends a document to the Yuanqi platform so it can be processed and used by agents for context.

### delete_file
Removes an uploaded file from your account's knowledge base documents.

### get_assistant_info
Retrieves detailed metadata and configuration settings for a specified assistant ID.

### get_file_info
Fetches general metadata, like file name or size, for a specific uploaded document.

## Prompt Examples

**Prompt:** 
```
Chat with assistant 'assistant_123' and ask 'Explain the concept of deep learning'.
```

**Response:** 
```
I'm connecting to the Yuanqi engine... Assistant 'assistant_123' responded: 'Deep learning is a subset of machine learning based on artificial neural networks...' Would you like me to save this response to your notes?
```

**Prompt:** 
```
Upload the file 'specs.pdf' to my Yuanqi account.
```

**Response:** 
```
Uploading 'specs.pdf'... Successfully uploaded! File ID: `file_xyz789`. The document is now being processed for the knowledge base. I'll let you know when it's ready.
```

**Prompt:** 
```
List all assistants in my account.
```

**Response:** 
```
Fetching your assistant list... I found 2 assistants: 1. ResearchBot (ID: asst_1), 2. CodeHelper (ID: asst_2). Which one would you like to interact with?
```

## Capabilities

### Interact with AI Assistants
You can send messages to published agents and track the conversation context using the `chat` tool.

### Control Document Lifecycle
The server lets you upload files (`upload_file`), list them (`list_files`), or delete them (`delete_file`) from your knowledge base.

### Track File Processing Status
Use `get_file_status` to monitor if a document is finished being indexed and ready for agent use.

### Manage Agent Metadata
Retrieve detailed configuration or basic information about any existing assistant with `get_assistant_info`.

### Monitor API Usage
Check your current token consumption and remaining quota using the `get_usage` tool, which is critical for billing and planning.

## Use Cases

### The Agent needs context before answering.
A user asks a question that requires company specs. Instead of just calling `chat`, your agent first calls `upload_file` with the 'specs.pdf'. Then, it waits for the document to process (checking via `get_file_status`) and finally executes `chat` using the newly indexed context. This ensures accurate answers every time.

### Auditing a production agent's behavior.
A product team needs to know if they are close to hitting their usage limit. They run an API call that executes `get_usage` first, checking the quota. This prevents service interruption and allows them to scale up before users even notice a slowdown.

### Debugging agent configuration.
A developer is debugging why one specialized bot isn't responding correctly. They use `list_assistants` to verify the correct ID, then call `get_assistant_info` for that ID. This confirms all parameters are set up right before they attempt a test `chat`.

### Maintaining data hygiene.
A knowledge manager finds old, irrelevant documents in the system. They use `list_files` to see everything stored, then systematically call `delete_file` on every document that shouldn't be indexed anymore.

## Benefits

- Stop guessing if a document is indexed. Use `get_file_status` to confirm real-time processing status before an agent attempts to read it.
- Never lose track of your agents. With `list_assistants`, you get a clear inventory, letting you quickly select the right assistant ID for chat or development calls.
- Keep costs predictable. The `get_usage` tool lets you monitor API token consumption programmatically, so you don't hit an unexpected quota wall mid-run.
- Build full knowledge graphs. You can use `upload_file` to ingest source materials and then call `chat` using those files as context for deep agent responses.
- Clean up old data. Need to remove a document from the system? Use `delete_file` instead of relying on manual dashboard deletion.
- Get full control over your environment. The `get_assistant_info` tool lets you pull metadata, ensuring your application knows exactly what parameters an assistant requires.

## How It Works

The bottom line is that this MCP lets you wrap all of Yuanqi's backend operations (file handling, chat, usage tracking) into your existing agent framework.

1. First, subscribe to the server. Then, log into the Tencent Yuanqi platform and generate an API Key under your 'My Creations' area.
2. Next, insert that API Key and your Assistant ID into the client fields provided by Vinkius.
3. Your AI client can now use the nine tools—calling them through structured prompts to manage agents or documents.

## Frequently Asked Questions

**How do I check if my uploaded file is ready for use with chat?**
You must call `get_file_status` first. This tool checks the document's processing state, letting you know exactly when it moves from 'uploaded' to 'ready,' which prevents your agent from failing.

**What should I use if I need a list of all available assistants?**
Use `list_assistants`. It gives you an immediate, machine-readable inventory of every assistant ID in your workspace. This is better than manually navigating the UI.

**Does the chat tool handle file context automatically?**
No, it doesn't. You must use `upload_file` and confirm readiness with `get_file_status` *before* calling the `chat` tool to ensure the agent uses your desired documents.

**How can I track my token usage programmatically?**
Call `get_usage`. This returns a direct report on your current API quota and consumption, letting you build limits into your application logic before they hit zero.

**How do I check the full configuration of an agent using `get_assistant_info`?**
It retrieves all metadata and setup details for any specific assistant ID. This lets you verify parameters or see if an agent needs updates before calling it.

**What command should I use to list every document uploaded using `list_files`?**
`list_files` returns the IDs and names of every document linked to your account. You can run this tool for an audit of all knowledge bases available.

**If a document is obsolete, how do I permanently remove it with `delete_file`?**
The `delete_file` tool removes the file ID you provide from your knowledge base. Note that this action is irreversible; double-check the file ID first.

**Before using a document, how can I inspect its details with `get_file_info`?**
This tool pulls the complete metadata for any given file ID. You get details like size and upload date without having to process or read the content.

**Can my AI automatically find the details of an assistant just by providing its ID?**
Yes! Use the `get_assistant_info` tool with the Assistant ID. Your agent will respond with complete metadata, configuration, and capabilities connected to that specific agent in seconds.

**How do I check the remaining token quota for my account?**
Simply ask the agent to run the `get_usage` action. It will retrieve the current token consumption statistics and the remaining quota provided by the Yuanqi platform.

**Can I upload multiple files for my assistant's knowledge base?**
Yes! Use the `upload_file` tool for each document you want to add. After uploading, use the `list_files` tool to verify they are processed and available for RAG operations.