> For the complete documentation index, see [llms.txt](https://docs.cherryai.com.cn/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.cherryai.com.cn/docs/en-us/advanced-basic/agent-an-li/gold-price-case.md).

# Confused by the gold price crash? I used Kimi K2.5 + Cherry Studio to build a 'replay analysis tool' (with Agent design + full tutorial)

Recently, gold has taken a sharp dive, and many people's first reaction is: should I run? Should I buy the dip?\
But looking back, what gold is best at is “putting strength on the market.” Its violent swings often mirror history:

* **Macro expectations suddenly shift**(interest rates / inflation / a stronger dollar), gold tends to pull back quickly
* **Risk events heat up**(conflicts, financial system stress), safe-haven demand pushes prices up again
* **When liquidity is tight**you may even see the counterintuitive pattern of “fall first, then rise”

The problem is: scrolling through ten news stories gives you emotion; but what you need is**an evidence chain**.\
Coincidentally, Moonshot AI recently released and open-sourced **Kimi K2.5** model. It is Kimi’s most intelligent and most versatile open-source model to date, reaching open-source SOTA in **Agent, code, image/video** and other tasks.

\
**So I came up with a bold idea:** Since the human brain can't process this much messy information,**could I let Kimi K2.5 live inside Cherry Studio’s Agent and help me dig into this “gold crash” from top to bottom?**

Today’s piece is not a dry manual, but a way to use the latest model and the most hardcore Agent skills to equip yourself with a 24/7 financial analysis team. At the end, I’ll provide the folder for this Agent `Kimi Agent`.

After you download it and spend 3 minutes configuring it, it will run. Below, I’ll break down the design logic, folder structure, component breakdown, and execution flow. If you’re staring at candlesticks and wondering whether to buy the dip, or getting bombarded by news but can’t find the real cause, you need this.<br>

<figure><img src="https://mcnnox2fhjfq.feishu.cn/space/api/box/stream/download/asynccode/?code=YWQxY2VjNGU3NmU5NzY1NWZmNDU3YzdiZGQyN2EwOTFfQ1JFRm52WVhJRGV2aGhQaGJsbDR2clltWkdoUmRHTGRfVG9rZW46WHlURGI3NWk5b1FKaEt4bnZZdGNEUjM1blhjXzE3NzAwMTYyNzc6MTc3MDAxOTg3N19WNA" alt=""><figcaption></figcaption></figure>

## **Why design it this way? (3 hard logic points, no detours)**

1. **Truthful data first, zero tolerance for fabrication**: Financial analysis fears “AI hallucinations” the most. So every step is forced to cite sources + timestamps; if it can’t fetch them, it errors out (no guessing). Public sources (like Kitco, Investing.com) ensure there’s zero API key barrier.
2. **Task modularization + parallelization**: The highlight of Kimi K2.5 is its “Agent cluster” (self-replicating, parallel 1500-step execution). We simulate this with Cherry Studio’s Skills + Sub-agents: data fetching, news gathering, and report generation run in parallel, doubling efficiency.
3. **Modern output**: No Markdown dump (who still reads plain text?), directly generate HTML (Chart.js charts + responsive layout), on par with Kimi K2.5’s code generation ability.

Result: one report = a chart over the past year + crash timeline + three-scenario forecast + full source links. Send it to your boss/group chat and it’s ready to use immediately.<br>

### **📁 Folder structure: Why is it compatible with Claude Code?**

The core is `.claude/` directory — Cherry Studio recognizes this, and it can automatically load Skills and configuration. The full structure comes from your `06-DIRECTORY_STRUCTURE.md`:

<figure><img src="https://mcnnox2fhjfq.feishu.cn/space/api/box/stream/download/asynccode/?code=MGE5ODBmMWIxYjQ0Yzc2MTU2YzBiMmVkMzFiYzliMWVfelFBa2k5YnV2RXRzQVVGN3A2eW51SlllbU5yN3lZVW9fVG9rZW46S1ZKSWJ6WHFjbzNYZkJ4MnR3QmNiQkNIbjRmXzE3NzAwMTYyNzc6MTc3MDAxOTg3N19WNA" alt=""><figcaption></figcaption></figure>

```python
Kimi Agent/                           # Project root
├── .claude/                          # Cherry Studio Agent core config area
│   ├── prompts/                      # System prompts (bilingual)
│   │   ├── system_prompt_cn.md       # Chinese version: defines Agent behavior + data truth rules
│   │   └── system_prompt_en.md       # English version
│   ├── skills/                       # 3 core Skills (auto-detected)
│   │   ├── skill_financial_data_fetcher.md     # Data fetching + validation
│   │   ├── skill_geopolitical_analyst.md       # Event analysis + timeline
│   │   └── skill_financial_report_generator.md # HTML report generation
│   ├── agents/                       # Sub-agent configuration
│   │   ├── subagent_financial_intelligence.md  # Quantitative analysis submodule
│   │   └── subagents_usage_strategy.md         # Collaboration strategy
│   ├── config/                       # Path/tool configuration
│   │   └── paths.conf
│   ├── settings.json                 # Main config: model + prompt paths + tool list
│   └── mcp.json                      # MCP (tool server) configuration
├── docs/                             # Document backup (README, data sources, changelog)
├── start-gold-agent.sh               # One-click launch script (optional)
├── USER_PROMPT_EXAMPLE.md            # Example prompt
└── Backup directory (core_config/ skills/ etc.) # Original file backup, not used at runtime
```

**Why split it up this way?**

* `.claude/` This is Cherry Studio’s standard recognition path: select the working directory, and it automatically loads Skills (filename `skill_*.md` → Skill name `financial-data-fetcher`).
* Backup area prevents loss: the original Skills are in the root-level skills/ folder, and at runtime use `.claude/skills/`.

<br>

### **🔧 Core component breakdown: 3 Skills + plugins + Sub-agents**

#### **🧩 Design details of the three core Skills**

Let’s look at how these three “copies” are specifically designed, and why they’re designed this way.

**Skill A:`financial-data-fetcher` (data hunter) — rejects hallucinations**

* **Design pain point**: A general LLM is most likely to “make up” prices. If you ask for gold prices, it might invent data from 2023 for you.
* **Skill logic**:
  * **hard constraint**: We hard-coded the rules in the Prompt —*“It is forbidden to use prices from training data; tools must be called”*.
  * **toolchain**: Equipped with `WebFetch`. It doesn’t go “search” Baidu; instead it directly “crawls” specified data-source pages (such as Kitco, GoldPrice.org, LBMA).
  * **Data cleaning**: It cleans the messy HTML it crawls into clean `JSON` format (timestamp, open, close, percentage change).
* **Role of Kimi K2.5**: Using its powerful**long-document extraction capability**, it can precisely locate that `$2,xxx.xx` number from tens of thousands of lines of webpage code.

**Skill B:`geopolitical-analyst` (geopolitical logic library) — rejects noise**

* **Design pain point**: There are many reasons for a gold crash (dollar up? war? selling?). Ordinary search will also suck in fake news from clickbait accounts.
* **Skill logic**:
  * **multi-source cross-checking**: It doesn’t just search for “gold price,” but also searches in parallel for “Dollar Index (DXY),” “Federal Reserve meeting minutes,” and “geopolitical conditions.”
  * **time alignment**: It executes a core logic —**“TimeStamp Matching”**.
    * *Found:* Gold plunged at UTC 14:30.
    * *Search:* What happened at UTC 14:30?
    * *Match:* Found that the U.S. released CPI data above expectations at UTC 14:30.
    * *Conclusion:* The plunge was triggered by inflation data.
* **Role of Kimi K2.5**: Using its **Agent cluster (copy) capability**, it can simulate “reading 20 news articles at once” and filter out emotional noise, keeping only facts.

**Skill C:`financial-report-generator` (front-end engineer) — rejects mediocrity**

* **Design pain point**: This is also Cherry Studio’s most impressive step. Most Agents only spit out a paragraph of Markdown text, and even tables are crooked.
* **Skill logic**:
  * **code first**: This Skill is trained to “speak only code language.” It doesn’t write articles; it writes HTML + CSS + JavaScript.
  * **dynamic interaction**: Even if you have no programming background, this component will call `Chart.js` library to turn the data fetched by Component A into a zoomable candlestick chart with hover inspection.
  * **visual integration**: It embeds Component B’s analytical conclusions into the webpage layout in the form of “cards” or a “timeline.”
* **Role of Kimi K2.5**: Using its upgraded **Code (programming)** capability, especially front-end build capability. The code generated by Kimi K2.5 is highly robust and can run in the browser with almost no manual debugging.

\ <br>

#### **What is the role of Sub-agents in this Agent setup? 🧩**

Now let’s make **Kimi Agent (gold market analysis Agent)** ’s “Sub-agent” layer clear: what it is, why it’s used, how it collaborates, and what you can see in the folder.

> *First, let’s be clear:* ***Skills** are more like “reusable process modules”;**Sub-agent** is more like “a dedicated role with its own work manual.”*

\
The main Agent (the one you create in Cherry Studio, `Gold Market Analysis Agent`) is responsible for three things:

1. **breaking down tasks**: splitting “analyze gold trends / review the crash / write report” into several independent subtasks
2. **assigning tasks**: distributing subtasks to different Sub-agents (each with clear boundaries and output formats)
3. **acceptance and aggregation**: checking whether data has sources and timestamps, whether there are gaps; then handing it to the report generation module to output HTML

Why not let one Agent do it all in one shot?

* Because “fetching data, reading news, calculating indicators, writing front-end reports” have different context and tool-call requirements, and cramming them into one Prompt is most likely to go off track.
* After splitting them up, each sub-agent’s rules can be made much stricter:**which tools are allowed, what structure to output, how to handle failures**.

\
**Which Sub-agents are in this setup? What does each do? ✅**&#x54;here are mainly three types of Sub-agents in this package (two are system presets, one is custom):

**A. System preset:`search-specialist`(search and information organization)**

* **name**: `search-specialist`
* **responsibilities**: advanced search, result filtering, cross-source verification, citation organization
* **output characteristics**: provides search strategy, source URLs, key quotations (suitable for making a “timeline of crash triggers”)

In gold analysis, it is usually responsible for:

* news sources, publication times, and key sentences related to the “crash”
* official/authoritative source pages for central bank and macro data releases (such as CPI, rate decisions)
* multi-source verification of the same indicator (for example, Kitco vs GoldPrice vs Investing)

**B. System preset:`business-analyst`(indicator and correlation analysis)**

Its tools are `Read, Write, Bash`, very suitable for**structured analysis**:

* correlations (gold vs DXY, gold vs real interest rates)
* ETF holdings changes (such as SPDR Gold Trust)
* KPI calculations (annualized volatility, drawdown, etc. — provided real data has been obtained)

Its value lies in:**turning descriptions that merely “look like analysis” into conclusions that are “computable and have intermediate steps.”**

**C. Custom Sub-agent:`financial-intelligence-agent`(historical data / technical indicators / forecasting)**

Path:`.claude/agents/subagent_financial_intelligence.md`It covers work that is more of a “quant pipeline”:

* fetch historical data (OHLCV, economic indicators, interest rates, inflation, etc.)
* calculate RSI / MACD / Bollinger Bands / moving averages / volatility
* output a set of traceable intermediate files: CSV, JSON (for example `gold_technical_indicators.csv`、`correlation_analysis.json`、`gold_price_forecast_12m.csv`)

> *This layer is especially important: it strips “technical analysis” out of chat content and turns it into artifacts that can be saved to disk. It’s easy to reuse, compare, and share with others.*

<br>

#### **How are Sub-agents “scheduled”? (parallel strategy) ⚙️**

This system prioritizes **parallelization**, because reviewing gold naturally involves multi-source information tasks.

**Phase 1: Parallel collection (reduce waiting)**

* `search-specialist`: search for the key news/data release timeline on the day of the crash
* `financial-intelligence-agent`: pull the price series for the past year + calculate indicators
* `business-analyst`: calculate correlations, organize explanatory frameworks for ETFs/macros

**Phase 2: Serial calculation (dependencies go later)**

* Only after historical data is written to disk do we calculate indicators / volatility / support and resistance, etc.
* If data gaps are found, go back to `search-specialist` supplement sources

**Phase 3: Summary delivery**

* The main Agent aligns the timestamps and definitions of the three result streams
* then calls the report generation module to output HTML (including charts, timeline, and source list)

This is why this Agent performs better in “hotspot scenarios”: **gold crash = information-dense + inconsistent definitions**, parallel evidence gathering + verification + summarization can significantly reduce the “I saw a lot but feel even more confused” problem.

***

#### **The relationship between Sub-agents and Skills: don’t mix them up 🤝**

In your package, the two are complementary:

* **Sub-agent**: more like a “dedicated work mode,” solving the problems of “who does it, how it’s done, which tools to use, and what format to output”
* **Skills (.claude/skills/)**: more like “reusable process modules,” solving the problem of “how to execute this step stably” For example:
  * `financial-data-fetcher`: emphasizes multi-source verification, forbids inventing numbers, outputs structured data
  * `geopolitical-analyst`: emphasizes event classification, causal mechanisms, timeline format
  * `financial-report-generator`: emphasizes HTML templates, Chart.js, source lists, printable styles

In short: **Sub-agents are responsible for distributing the work; Skills are responsible for making each step more stable and reusable.**<br>

#### **How do you confirm in the folder that the Sub-agent is actually “working”? 🔍**

Just check two places:

1. **whether the directory is standard**
   1. `.claude/agents/` contains `subagent_financial_intelligence.md`
2. **runtime logs**(inside Cherry Studio)
   1. you’ll see traces of tool calls and task delegation (WebSearch/WebFetch/Bash/Write)
   2. it can finally generate files: for example `gold_analysis_report.html`, and if intermediate artifacts are configured, it will also output CSV/JSON

If you want it to be more obvious, you can add a hard constraint to the main Prompt:

> *“Please list in the report appendix which sub-agents / skills were called this time, and the filenames each produced.”*

That way readers can tell at a glance: this isn’t chatting, this is a pipeline.<br>

## **🛠️ Hands-on tutorial: Recreate your own Agent in three steps**

No coding needed, no environment setup needed. I’ve bundled &#x61;**“Kimi Agent” folder**for you, and all you need is copy-paste to use it.

### **Step 1: Model configuration (Moonshot AI’s `kimi-K2.5` + Anthropic endpoint)**

This is the core that makes the AI smart.

1. Open Cherry Studio → **Model Services** → click **Moonshot AI**

<figure><img src="https://mcnnox2fhjfq.feishu.cn/space/api/box/stream/download/asynccode/?code=ODM3MTNkZDUzMDVlODQ2MWMyZjc1ODA2YmRjZDYzMjlfN29ERG56cTRYWU44bE14T1NWS1lQMzl4dUo3Uzc1MWFfVG9rZW46SmY1ZmJQS1ZjbzhVY3F4dEZxSmM0V0dRbnZnXzE3NzAwMTYyNzc6MTc3MDAxOTg3N19WNA" alt=""><figcaption></figcaption></figure>

2. go to the Moonshot AI Open Platform to get **API Key**(required for model calls; data fetching does not require an extra key)

**⚠️ High-energy warning (must do):** In Cherry Studio’s settings, change **“Endpoint Type”** to `Anthropic`.

<figure><img src="https://mcnnox2fhjfq.feishu.cn/space/api/box/stream/download/asynccode/?code=N2QwZGIwZThhNjg5MDIzNDQ4NTUzNzdlOWU2M2Q0N2VfN1A0UzB0R3QyUTFIRDJGV05FN0UxVkVwa0d3MGM0RHRfVG9rZW46SDc1OGIxZ1N1b1d2TkF4MXZiRWNPcmpnbktoXzE3NzAwMTYyNzc6MTc3MDAxOTg3N19WNA" alt=""><figcaption></figcaption></figure>

* *Why change it?* Because Cherry Studio’s Agent protocol needs to run in Anthropic endpoint mode so that Kimi K2.5 can perfectly orchestrate the Skills mentioned above.

\ <br>

### **Step 2: Create the Agent (mount the folder directly `Kimi Agent`)**

> At the end, I’ve prepared a folder named `Kimi Agent` for you, which comes preloaded with all the skills, so you don’t need to manually rewrite the Skills/Sub-agent.

<figure><img src="https://mcnnox2fhjfq.feishu.cn/space/api/box/stream/download/asynccode/?code=YWEzYzJlOTBmNzJiNDJiYTBlZmNkNmFjOGE0MDQ1MjdfYkY1SEtLckNTNHQxd1RRQXg5VnBRR2ZaRVM2VFM5MVBfVG9rZW46UzNvQmIxdFpmb3RkQ1J4dlZzT2NLbUZLbmJnXzE3NzAwMTYyNzc6MTc3MDAxOTg3N19WNA" alt=""><figcaption></figcaption></figure>

1. In Cherry Studio, click next to the assistant list **+** → **Create Agent**
2. Name:`Gold Market Analysis Agent`(or whatever name you like).
3. Model: choose the newly configured **Moonshot AI /** `kimi-K2.5`
4. Working directory: choose the `Kimi Agent` folder you downloaded and extracted

<figure><img src="https://mcnnox2fhjfq.feishu.cn/space/api/box/stream/download/asynccode/?code=YTRjNzk5Nzk5Mzc1NzE2MjgwMjYxZDYwNzZjYjQzMzZfbDV2OXhON1lzbEZpNGNKeWtWRDJManJnUkxPbDh6U2lfVG9rZW46RVFZWGJ3VkxJb2lKWkh4TThscmN6b1ZPbm5mXzE3NzAwMTYyNzc6MTc3MDAxOTg3N19WNA" alt=""><figcaption></figcaption></figure>

5. Open the system prompt in the folder (for example `.claude/prompts/system_prompt_cn.md`), paste it into Cherry Studio’s **System Prompt**box.

<br>

### **Step 3: Turn on tool permissions + plugins + Skills (check everything as listed)**

<br>

1. **Enable permissions**: In the Agent settings, enable permissions and authorize tools (missing even one may cause it to stall):

<figure><img src="https://mcnnox2fhjfq.feishu.cn/space/api/box/stream/download/asynccode/?code=YTU4NGU3MGJjZTA1NzY3YjJmMWE1ODZlM2M1ZTY5NzhfUEVXZW91V0Vta2lBUnNubjNEaU9DanVsVkZNOGEyZ0hfVG9rZW46UnkzVGJrUjFTb21XQUp4NlpwRmM5dkFybmloXzE3NzAwMTYyNzc6MTc3MDAxOTg3N19WNA" alt=""><figcaption></figcaption></figure>

* `bash`
* `fetch`
* `edit`
* `multiedit`
* `webfetch`
* `web search`
* `write`

2. **Configure plugins:**

Add the system preset plugin:

<figure><img src="https://mcnnox2fhjfq.feishu.cn/space/api/box/stream/download/asynccode/?code=M2Q4NzhhNmY4MTFjN2Y4MTk3NWFkM2M5OGE3YzExZGNfNm9CRlBrOTdkdkNEUjZxMnJKamFValdheE53NEF5NVhfVG9rZW46T3huTWJGQlo3b3NuNmJ4SnNHQWNIME50bjBmXzE3NzAwMTYyNzc6MTc3MDAxOTg3N19WNA" alt=""><figcaption></figcaption></figure>

* `business-analyst`
* `search-specialist`

system skills:

* `Excel Analysis`

<br>

## **witness the “magic”**

Everything is ready. Open the `USER_PROMPT_EXAMPLE.md`in the folder, where there is a ready-made**deep instruction**, and send it directly to the Agent.**This prompt will make the Agent do three things:**

<figure><img src="https://mcnnox2fhjfq.feishu.cn/space/api/box/stream/download/asynccode/?code=MzQ1NzEwZmMyZDJkMzg5NjgyZjQ5ZmRmN2FkNmZhZDZfUEZzcHpEUzFaZlBja2xWZVpOYjhOM0Q3RVJGbUtpSnpfVG9rZW46WnpyU2JhbDZvbzBmT0F4UGFaUWNSR1RCbmVqXzE3NzAwMTYyNzc6MTc3MDAxOTg3N19WNA" alt=""><figcaption></figcaption></figure>

1. **check**: search for the specific drop percentage and the time it happened for the gold crash.
2. **find**: use Kimi K2.5’s online capability to find Moonshot AI’s official introduction to the new model’s features (do not make things up).
3. **compare**: find similar crash patterns in history and analyze whether there is an “echo” relationship.

### **📊 Final result: what did it deliver?**

Click send and you’ll see the Agent start running wildly. The logs will show:`Thinking...` -> `Searching News...` -> `Calculating...`After a while, you won't get a bunch of nonsense, but instead receive a **deep-dive research report in HTML format**:

<figure><img src="https://mcnnox2fhjfq.feishu.cn/space/api/box/stream/download/asynccode/?code=Y2IzNzQyN2E5MDM2MWQ3MjA2YTc0NTE4Mzc1Y2IxZTFfUEJWV0ZtaTBJSGd3cHhsMUZ5YVVDRFhRUlNVYUhXbm1fVG9rZW46TVRFZmJSR2tPb2Z3dE14cUdmZWN4RTJabkRoXzE3NzAwMTYyNzc6MTc3MDAxOTg3N19WNA" alt=""><figcaption></figcaption></figure>

* 📈 **Visualization of gold trends over the past year**(charts + tables)
* 🧷 **Key spike/crash interval annotations**(especially "crash")
* 🗓️ **Event timeline**(each event includes a source link, so it can be verified)
* 📊 **Technical indicators/correlation analysis**(if there is data, calculate it; if missing, state it clearly)
* 🔮 **Three-scenario forecast**(clearly state conditions, ranges, and risk warnings)
* 🧾 **Data source list**(URL + crawl timestamp)

\
**In the end, you will get a** `gold_analysis.html` **file. Open it to view:**<br>

<figure><img src="https://mcnnox2fhjfq.feishu.cn/space/api/box/stream/download/asynccode/?code=MDI4NDk2Yzc4N2Q1MTAyMDFlYTkyMmFhNDZiNzUzMTJfVFQ2S1hJdkdjcXNLU2tDUzZzaGpoZ2UzYkpiMFl5ekZfVG9rZW46SzRTbGI5VXRLb0o5d2J4aE9nV2MwMDRsblJlXzE3NzAwMTYyNzc6MTc3MDAxOTg3N19WNA" alt=""><figcaption></figcaption></figure>

***

## **💭 Final thoughts**

What shocked me most this time was not how much stronger Kimi K2.5 became, nor how easy Cherry Studio is to use. It was **“certainty”**. In financial markets, information is money.

we've effectively hired ourselves a&#x6E;**“absolutely rational, 24/7 online, data-traceable”**&#x73;uper employee.

**You may not have dodged this gold plunge, but if you learn this Agent approach, at least on the cognitive level, you've already made it back.**\
\
Once you maste&#x72;**“breaking complex tasks down into Skills components”**&#x74;his core logic, plus **Kimi K2.5** the qualitative leap in task planning and tool invocation, you'll find that the things you used to think "AI couldn't do" can now all be handed off to Agents:

* **🕵️‍♂️ Market scout**： Don't want to manually browse competitors' websites? Let the Agent automatically scrape the latest prices and feature updates from 10 competitors, clean and deduplicate them, and push the organized Excel comparison table to your desktop every day at 9 a.m.
* **💻 Shadow programmer**： Can't finish the code? It's not just code completion—you can have the Agent read the entire project folder, automatically write feature modules based on requirements, run local tests, fix bugs, and even generate a perfect API document along the way.
* **✈️ Ultimate traveler**： Say no to checklist-style guides. Let the Agent compare flight and hotel prices in real time based on your budget, synthesize weather and local event reviews, plan an itinerary down to the minute, and even generate a PDF road book.

\
**The real appeal of an Agent lies not in how long it can chat with you, but in its autonomy and delivery capability**—it can, like today's gold analyst, quietly get the work done while you're having coffee. This sense o&#x66;**“task automation”**&#x6F;nce experienced, is hard to go back from.

We sincerely invite you to think outside the box and explore more hardcore, interesting, and practical scenarios. Whether it's workflow optimization or life hacks, please share your creative ideas and Agent configuration files.

📩 **Submissions and communication**:<support@cherry-ai.com>\
**Don't wait for the future. Your AI Agent era has already begun at this very moment.**

\
👇 **Download now, connect to Kimi K2.5, and build your first digital team:**

📥 **Appendix: Kimi Agent configuration folder download link:**<https://pan.quark.cn/s/1ef986d1a9ff>*(Please make sure Cherry Studio v1.7.0+ is installed)*<br>

\
\
\ <br>

***

### 💡 Get help and submit feedback

If you encounter any questions, bugs, or have suggestions for feature improvements during configuration or use, please refer to [Feedback and Suggestions](/docs/en-us/question-contact/suggestions.md) the official channels provided there.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.cherryai.com.cn/docs/en-us/advanced-basic/agent-an-li/gold-price-case.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.