> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.caesar.xyz/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.caesar.xyz/_mcp/server.

# Prompts

Caesar is a **horizontal general solution** for research that works across domains without requiring specialized prompt engineering. While Caesar doesn't need complex prompting strategies, being explicit in your queries will yield better, more targeted results.

## Writing effective queries

Caesar performs best when queries are clear and unambiguous. While the system is designed to understand context, explicit queries reduce ambiguity and improve result quality.

### Be specific about your domain

When your query involves terms that could have multiple interpretations, provide context to guide the research.

**`Better`**

```text Better
What are the top tokens in the virtuals agent ecosystem?
```

**`Avoid`**

```text Avoid
Top virtuals tokens
```

The first query clarifies you're asking about tokens within the "virtuals agent ecosystem," avoiding ambiguity around what "virtuals" means.

### More examples of explicit queries

#### Financial research

**Instead of:** "Apple performance"

**Use:** "Apple Inc. (AAPL) stock performance in Q3 2024 compared to tech sector peers"

#### Technology analysis

**Instead of:** "React vs Vue"

**Use:** "Comparison of React and Vue.js frameworks for enterprise web applications in 2024"

#### Market research

**Instead of:** "EV market"

**Use:** "Electric vehicle market penetration rates in European countries 2023-2024"

#### Cryptocurrency

**Instead of:** "Best L2s"

**Use:** "Top Ethereum Layer 2 scaling solutions by TVL and transaction throughput"

## Output transformation with system\_prompt

The `POST /research` endpoint accepts an optional `system_prompt` parameter that allows you to transform the final output format.

> **Warning**
>
> The `system_prompt` only affects the **output format**, not the research logic. Caesar performs the same comprehensive research regardless of the promptit only changes how the results are presented.

### How it works

When you provide a `system_prompt`:

1. Caesar performs the research using your query
2. The research results are stored in the `content` field
3. The system prompt is applied to transform the content
4. The transformed result appears in `transformed_content`

### Request example

### Request

POST [https://api.caesar.xyz/research](https://api.caesar.xyz/research)

```curl
curl -X POST https://api.caesar.xyz/research \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "query": "What are the latest advancements in renewable energy technologies?"
}'
```

```python
import requests

url = "https://api.caesar.xyz/research"

payload = { "query": "What are the latest advancements in renewable energy technologies?" }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.caesar.xyz/research';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"query":"What are the latest advancements in renewable energy technologies?"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.caesar.xyz/research"

	payload := strings.NewReader("{\n  \"query\": \"What are the latest advancements in renewable energy technologies?\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.caesar.xyz/research")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"query\": \"What are the latest advancements in renewable energy technologies?\"\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.caesar.xyz/research")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"query\": \"What are the latest advancements in renewable energy technologies?\"\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.caesar.xyz/research', [
  'body' => '{
  "query": "What are the latest advancements in renewable energy technologies?"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.caesar.xyz/research");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"query\": \"What are the latest advancements in renewable energy technologies?\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["query": "What are the latest advancements in renewable energy technologies?"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.caesar.xyz/research")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

```json
{
  "query": "Latest developments in quantum computing for drug discovery",
  "system_prompt": "Format the response as a bullet-point executive summary with key findings and implications"
}
```

### Response structure

When using `system_prompt`, the response includes both original and transformed content:

```json
{
  "id": "abc123...",
  "status": "completed",
  "query": "Latest developments in quantum computing for drug discovery",
  "content": "Full research content with detailed analysis...",
  "transformed_content": "" Key Finding 1: IBM's quantum advantage in molecular simulation...\n" Key Finding 2: ...",
  "results": [...]
}
```

### Common transformation patterns

#### Executive summary

```json
{
  "system_prompt": "Provide a 3-paragraph executive summary highlighting key insights, implications, and recommendations"
}
```

#### Structured analysis

```json
{
  "system_prompt": "Structure the response with sections: Overview, Key Findings, Market Impact, Future Outlook"
}
```

#### Technical brief

```json
{
  "system_prompt": "Focus on technical specifications, implementation details, and comparative metrics"
}
```

#### Investment perspective

```json
{
  "system_prompt": "Analyze from an investment perspective, highlighting opportunities, risks, and market dynamics"
}
```

## Key principles

#### No prompt engineering required

Caesar understands context and intent without complex prompts. Focus on being clear rather than clever.

#### Clarity beats complexity

Simple, explicit queries outperform elaborate prompt chains. State exactly what you need.

#### Domain agnostic

Caesar works across all domainsfinance, technology, science, cryptowithout specialized prompts.

#### Transform, don't guide

System prompts transform output presentation, not research quality or scope.

## Tips for optimal results

1. **Include relevant context**: Mention time periods, geographic regions, or specific sectors when relevant
2. **Use industry-standard terminology**: Caesar understands domain-specific terms and acronyms
3. **Specify comparison criteria**: When comparing options, state what metrics or factors matter
4. **Set clear boundaries**: If you want specific scope (e.g., "only peer-reviewed sources"), state it explicitly

> **Note**
>
> Remember: Caesar performs comprehensive research regardless of how you phrase your query. Being explicit simply ensures the research focuses on exactly what you need.