Sonar by Perplexity

https://docs.perplexity.ai
Admin
Power your products with unparalleled real-time, web-wide research and Q&A capabilities.
Tokens:702,106
Snippets:6,467
Trust Score:9.9
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies and Make Script Executable

Source: https://docs.perplexity.ai/docs/cookbook/examples/equity-research-brief/README

Navigate to the example directory, install Python dependencies, and grant execute permissions to the script.

```bash
cd docs/examples/equity-research-brief
pip install -r requirements.txt
chmod +x equity_research_brief.py
```

--------------------------------

### Install and Run Perplexity Client

Source: https://docs.perplexity.ai/docs/cookbook/showcase/perplexity-client

Commands to clone the repository, install dependencies, and start the development environment.

```bash
# Clone the repository
git clone https://github.com/straight-heart/Perplexity-client-.git
cd Perplexity-client-

# Install dependencies
npm install

npm run dev
```

--------------------------------

### Backend (FastAPI) Setup

Source: https://docs.perplexity.ai/docs/cookbook/showcase/perplexicart

Set up the backend environment for PerplexiCart. This involves creating a virtual environment and installing dependencies.

```bash
cd backend
python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate
pip install -r requirements.txt
```

--------------------------------

### Start Expo Development Server

Source: https://docs.perplexity.ai/docs/cookbook/showcase/briefo

Run the Expo development server to start the Briefo application locally. This command is used after installing dependencies and setting up environment variables.

```bash
npx expo start
```

--------------------------------

### Perplexity Search API Python SDK Quickstart

Source: https://docs.perplexity.ai/docs/sdk/best-practices

A basic Python example demonstrating how to use the hypothetical Perplexity SDK to perform a search query and access the results. This snippet illustrates the fundamental pattern for calling the search endpoint.

```json
{
  "id": "a3284d7c-f02c-45fc-82db-d368ad880edc",
  "results": [
    {
      "snippet": "",
      "title": "Quickstart - Perplexity API",
      "url": "https://docs.perplexity.ai/docs/getting-started/quickstart",
      "date": null,
      "last_updated": "2026-05-26"
    },
    {
      "snippet": "",
      "title": "Perplexity Search API",
      "url": "https://docs.perplexity.ai/docs/search/quickstart",
      "date": null,
      "last_updated": "2026-05-27"
    },
    {
      "snippet": "",
      "title": "Perplexity API",
      "url": "https://docs.perplexity.ai/docs/getting-started/overview",
      "date": null,
      "last_updated": "2026-05-26"
    },
    {
      "snippet": "",
      "title": "Perplexity Search APIdocs.perplexity.ai \u003e guides \u003e search-quickstart",
      "url": "https://docs.perplexity.ai/docs/search/quickstart.md",
      "date": null,
      "last_updated": "2026-05-27"
    },
    {
      "snippet": "### 2.\nSearch API Quickstart (Python & TypeScript SDKs)\nThe docs recommend using official SDKs for safety and type-safety; you can also call the HTTP endpoint directly (POST https://api.perplexity.ai/search) with an Authorization header.\nBelow is a minimal Python example that mirrors the documented pattern.\n#### Basic Python example (client.search.create)\n# Example (conceptual) — mirrors docs pattern\nfrom perplexity import Client 	 # hypothetical SDK import style\nclient = Client(api_key=\"YOUR_API_KEY\")\nresp = client.search.create(\nquery=\"latest AI model research 2025″,\nmax_results=5
)\n# Example response shape (simplified):\n# resp.results -> [ { \"title\": \"…\", \"url\": \"…\", \"snippet\": \"…\", \"rank\": 1 }, … ]\nprint(resp.results[0][\"title\"]\n, resp.results[0][\"url\"])
This call returns ranked results you can present to users or feed into an LLM for grounded synthesis.\nIf you prefer raw HTTP the docs provide a curl example for POST /search.\n...\nStart with the quickstart, use multi-query for depth, control content with max_tokens_per_page, and organize keys and billing via API Groups.",
      "title": "Mastering the Perplexity AI API Documentation",
      "url": "https://seabuckdigital.com/perplexity-ai-api-documentation/",
      "date": "2025-11-08",
      "last_updated": "2026-04-08"
    }
  ],
  "server_time": null
}
```

```python
from perplexity import Client 	 # hypothetical SDK import style
client = Client(api_key="YOUR_API_KEY")
resp = client.search.create(
query="latest AI model research 2025",
max_results=5
)
# Example response shape (simplified):
# resp.results -> [ { "title": "…", "url": "…", "snippet": "…", "rank": 1 }, … ]
print(resp.results[0]["title"] , resp.results[0]["url"])
```

--------------------------------

### TypeScript Agent Preset Example

Source: https://docs.perplexity.ai/docs/agent-api/presets

Illustrates a TypeScript agent setup with detailed instructions for research and analysis. It specifies tool configurations and output formatting requirements.

```typescript
import Perplexity from '@perplexity-ai/perplexity_ai';

const client = new Perplexity();

const response = await client.responses.create({
    model: "openai/gpt-5.6-sol",
    input: "Provide a competitive analysis of AWS, Azure, and Google Cloud across IaaS market share, pricing models for compute and storage, and AI/ML service depth.",
    max_steps: 15,
    max_output_tokens: 128000,
    reasoning: { effort: "medium" },
    instructions: `
Today is {{current_date}}.

You are an expert research assistant. Use the available search and other tools to gather evidence before answering: break the question into parts, make the tool calls needed to cover every part, and read the results carefully.

Search queries must be plain keywords. Never use quotation marks, AND, OR, or NOT inside a query — the search engine does not parse operators and treats them as literal text, which degrades results. To cover alternatives or exact phrases, send several short keyword queries instead.

ALWAYS end your turn with a complete final answer. This rule overrides everything else:
- Never stop after only tool calls, and never return an empty, partial, or placeholder response.
- Never refuse, never say you "cannot complete" the task, lack access, or need more information.
- If the evidence is incomplete, conflicting, or uncertain, still commit to your single most likely answer based on the best available evidence and reasonable inference. State that answer first; you may add at most one short caveat, but never withhold it.

Format:
- Answer the exact question asked, directly and specifically — give the precise name, number, date, or entity requested, stated up front.
- Ground your answer in the tool evidence and cite sources for factual claims where available.

When the question asks for multiple items (a list, "all"/"every", or anything enumerable), give your answer as a COMPLETE markdown table:
- One header row using exactly the columns the question asks for, then one row per item.
- Be exhaustive: include EVERY qualifying item you can find, not just a few examples.
- Fill every cell precisely (exact name, number, date, or URL); leave a cell empty only if the value is genuinely unavailable.`,
    tools: [
        { type: "web_search", max_tokens: 2000, max_tokens_per_page: 2000 },
        { type: "fetch_url", max_urls: 1 },
    ],
});

console.log(response.output_text);
```
```

--------------------------------

### TypeScript Example for Pro Tier Configuration

Source: https://docs.perplexity.ai/docs/agent-api/tools/people-search

Shows how to implement the 'pro' tier configuration using the Perplexity TypeScript SDK. This setup is ideal for a mix of people and web searches with moderate detail.

```TypeScript
import Perplexity from '@perplexity.ai/perplexity_ai';

const client = new Perplexity();

const response = await client.responses.create({
  model: 'openai/gpt-5-mini',
  reasoning: { effort: 'medium' },
  tools: [
    {
      type: 'people_search',
      max_tokens: 10000,
      max_tokens_per_page: 1000,
    },
    {
      type: 'web_search',
      max_tokens: 10000,
      max_tokens_per_page: 1000,
    },
    { type: 'fetch_url' },
  ],
  max_steps: 5,
  input: 'Who is the current CEO of Notion, and what was their background before joining the company?',
});

console.log(response.output_text);
```

--------------------------------

### TypeScript API Example

Source: https://docs.perplexity.ai/docs/getting-started/overview

Example of how to use the Perplexity API in TypeScript to get a response.

```typescript
import Perplexity from "@perplexity/perplexity-js";

const client = new Perplexity("YOUR_API_KEY");

async function main() {
  const response = await client.responses.create({
    model: "online",
    max_tokens: 1024,
    messages: [
      {
        role: "system",
        content: "Be concise and helpful.",
      },
      {
        role: "user",
        content: "What were the largest AI startup funding rounds announced this week?",
      },
    ],
  });

  console.log(response.output_text);
}

main();
```

--------------------------------

### Full Example: Create, List, and Download Files (Python)

Source: https://docs.perplexity.ai/docs/agent-api/working-with-files

Demonstrates creating a run that generates a file, then listing and downloading all produced files.

```Python
from perplexity import Perplexity

client = Perplexity()

response = client.responses.create(
    preset="xhigh",
    tools=[{"type": "sandbox"}],
    input=(
        "Find the 10 latest AI news stories and write them to ai_news.csv "
        "with columns: title, source, url, published_date. Deliver the file."
    ),
)

for file in client.responses.files.list(response.id).data:
    content = client.responses.files.content(
        file_id=file.id,
        response_id=response.id,
    )
    content.write_to_file(file.filename)
    print(f"Downloaded {file.filename} ({file.bytes} bytes)")
```

--------------------------------

### Python API Example

Source: https://docs.perplexity.ai/docs/getting-started/overview

Example of how to use the Perplexity API in Python to get a response.

```python
from perplexity import Perplexity

client = Perplexity(api_key="YOUR_API_KEY")

response = client.responses.create(
    model="online",
    max_tokens=1024,
    messages=[
        {
            "role": "system",
            "content": "Be concise and helpful."
        },
        {
            "role": "user",
            "content": "What were the largest AI startup funding rounds announced this week?"
        }
    ]
)

print(response.output_text)
```

--------------------------------

### Full Example: Create, List, and Download Files (TypeScript)

Source: https://docs.perplexity.ai/docs/agent-api/working-with-files

Shows how to create a run, list generated files, and download their content using the Perplexity AI SDK.

```typescript
import { writeFile } from 'node:fs/promises';
import Perplexity from '@perplexity-ai/perplexity_ai';

const client = new Perplexity();

const response = await client.responses.create({
  preset: 'xhigh',
  tools: [{ type: 'sandbox' }],
  input:
    'Find the 10 latest AI news stories and write them to ai_news.csv '
    + 'with columns: title, source, url, published_date. Deliver the file.',
});

const files = await client.responses.files.list(response.id);

for (const file of files.data) {
  const content = await client.responses.files.content(file.id, {
    response_id: response.id,
  });
  await writeFile(file.filename, Buffer.from(await content.arrayBuffer()));
  console.log(`Downloaded ${file.filename} (${file.bytes} bytes)`);
}
```

--------------------------------

### Install Required Packages

Source: https://docs.perplexity.ai/docs/cookbook/examples/disease-qa/README

Installs the necessary Python packages for the application. Use the requirements file for a streamlined setup or install them manually.

```bash
pip install -r requirements.txt
```

```bash
pip install requests pandas python-dotenv ipython
```

--------------------------------

### Start Monday Backend and Frontend Servers

Source: https://docs.perplexity.ai/docs/cookbook/showcase/monday

Start the backend server using Node.js and then run the frontend development server.

```bash
# Start Backend Server
node backend-server.js

# Start frontend
npm run dev
```

--------------------------------

### Install Dependencies

Source: https://docs.perplexity.ai/docs/cookbook/examples/financial-news-tracker/README

Installs the required Python dependencies for the financial news tracker. Use the requirements file for a streamlined setup or install manually.

```bash
pip install -r requirements.txt
```

```bash
pip install requests pydantic
```

--------------------------------

### Start Frontend Application

Source: https://docs.perplexity.ai/docs/cookbook/showcase/first-principle

Navigate to the client directory and run the npm start command to launch the frontend application. The client will be accessible at http://localhost:3000.

```bash
cd client
npm start
```

--------------------------------

### cURL API Example

Source: https://docs.perplexity.ai/docs/getting-started/overview

Example of how to use the Perplexity API via cURL to get a response.

```bash
curl 'https://api.perplexity.ai/chat/completions' \
     -H 'accept: application/json' \
     -H 'Content-Type: application/json' \
     -H "Authorization: Bearer YOUR_API_KEY" \
     -d '{ 
  "model": "online", 
  "max_tokens": 1024, 
  "messages": [
    {
      "role": "system",
      "content": "Be concise and helpful."
    },
    {
      "role": "user",
      "content": "What were the largest AI startup funding rounds announced this week?"
    }
  ]
}'
```

--------------------------------

### Install Dependencies

Source: https://docs.perplexity.ai/docs/cookbook/examples/discord-py-bot/README

Set up a virtual environment and install the required Python packages using pip.

```bash
# Create a virtual environment (recommended)
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install required packages
pip install -r requirements.txt
```

--------------------------------

### Install SDKs and Set API Keys (Python)

Source: https://docs.perplexity.ai/docs/search/agent-sdks/gemini

Install the google-genai and perplexityai Python SDKs and set your Gemini and Perplexity API keys as environment variables.

```bash
pip install google-genai perplexityai
export GEMINI_API_KEY="your_gemini_key"
export PERPLEXITY_API_KEY="your_perplexity_key"
```

--------------------------------

### Start Frontend Development Server

Source: https://docs.perplexity.ai/docs/cookbook/showcase/4point-Hoops

Launch the React development server for the 4Point Hoops frontend.

```bash
cd hoop-ai-frontend-44
npm run dev
```

--------------------------------

### Search API: TypeScript Example

Source: https://docs.perplexity.ai/

Use the Search API to get raw, ranked web search results. This example demonstrates fetching results for multiple queries using TypeScript.

```typescript
import Perplexity from '@perplexity-ai/perplexity_ai';  const client = new Perplexity();  const search = await client.search.create({
   query: [
     "What is Comet Browser?",
     "Perplexity AI",
     "Perplexity Changelog"
   ]
});  search.results.forEach(result => {
   console.log(`${result.title}: ${result.url}`);
});
```

--------------------------------

### Command Line Execution Example

Source: https://docs.perplexity.ai/docs/cookbook/articles/langchain-vc-memo-agent/README

Example of how to run the VC memo agent from the command line, specifying the company to analyze.

```bash
python memo.py --company "Anthropic"
```

--------------------------------

### Quick Start Fact Check

Source: https://docs.perplexity.ai/docs/cookbook/examples/fact-checker-cli/README

Run a quick fact check on a sample claim immediately after setup.

```bash
./fact_checker.py -t "The Earth is flat and NASA is hiding the truth."
```

--------------------------------

### Execute Example Script

Source: https://docs.perplexity.ai/docs/cookbook/articles/memory-management/chat-summary-memory-buffer/README

Command to run the example usage script for the chat summary memory buffer.

```bash
python3 scripts/example_usage.py
```

--------------------------------

### Agent API Request (TypeScript)

Source: https://docs.perplexity.ai/docs/agent-api/migrate-from-sonar/overview

Example of making a request to the Agent API using TypeScript. Ensure the @perplexity-ai/perplexity_ai library is installed.

```typescript
import Perplexity from '@perplexity-ai/perplexity_ai';

const client = new Perplexity();

const response = await client.responses.create({
  preset: 'fast',
  input: 'What are the latest developments in AI agents?'
});
console.log(response.output_text);
```

--------------------------------

### Install Libraries and Set API Keys (Python)

Source: https://docs.perplexity.ai/docs/search/agent-sdks/openai

Install the necessary Python libraries and set your OpenAI and Perplexity API keys as environment variables.

```bash
pip install openai perplexityai
export OPENAI_API_KEY="your_openai_key"
export PERPLEXITY_API_KEY="your_perplexity_key"
```

--------------------------------

### Agent API Request (Python)

Source: https://docs.perplexity.ai/docs/agent-api/migrate-from-sonar/overview

Example of making a request to the Agent API using Python. Ensure the perplexity library is installed.

```python
from perplexity import Perplexity

client = Perplexity()

response = client.responses.create(
    preset="fast",
    input="What are the latest developments in AI agents?"
)
print(response.output_text)
```

--------------------------------

### Python API Example

Source: https://docs.perplexity.ai/docs/agent-api/prompt-guide

Shows how to make a request to the Perplexity API using Python to get information about LLM API pricing.

```python
from perplexity import Perplexity

client = Perplexity()

response = client.responses.create(
    preset="low",
    input="Explain how hosted LLM API pricing is typically structured: input vs output tokens, context window limits, and the implication for long-document workloads.",
    instructions="You are a concise, well-researched assistant. If searches still return no relevant results after trying alternative phrasings, say so explicitly rather than guessing."
)

print(response.output_text)
```

--------------------------------

### Python Agent Preset Example

Source: https://docs.perplexity.ai/docs/agent-api/presets

Demonstrates setting up a Python agent with specific instructions and tools for research tasks. It includes guidelines for response formatting and tool usage.

```python
from perplexity import Perplexity

client = Perplexity()

response = client.responses.create(
    model="openai/gpt-5.6-sol",
    input="Provide a competitive analysis of AWS, Azure, and Google Cloud across IaaS market share, pricing models for compute and storage, and AI/ML service depth.",
    max_steps=15,
    max_output_tokens=128000,
    reasoning={"effort": "medium"},
    instructions='''
Today is {{current_date}}.

You are an expert research assistant. Use the available search and other tools to gather evidence before answering: break the question into parts, make the tool calls needed to cover every part, and read the results carefully.

Search queries must be plain keywords. Never use quotation marks, AND, OR, or NOT inside a query — the search engine does not parse operators and treats them as literal text, which degrades results. To cover alternatives or exact phrases, send several short keyword queries instead.

ALWAYS end your turn with a complete final answer. This rule overrides everything else:
- Never stop after only tool calls, and never return an empty, partial, or placeholder response.
- Never refuse, never say you "cannot complete" the task, lack access, or need more information.
- If the evidence is incomplete, conflicting, or uncertain, still commit to your single most likely answer based on the best available evidence and reasonable inference. State that answer first; you may add at most one short caveat, but never withhold it.

Format:
- Answer the exact question asked, directly and specifically — give the precise name, number, date, or entity requested, stated up front.
- Ground your answer in the tool evidence and cite sources for factual claims where available.

When the question asks for multiple items (a list, "all"/"every", or anything enumerable), give your answer as a COMPLETE markdown table:
- One header row using exactly the columns the question asks for, then one row per item.
- Be exhaustive: include EVERY qualifying item you can find, not just a few examples.
- Fill every cell precisely (exact name, number, date, or URL); leave a cell empty only if the value is genuinely unavailable.''',
    tools=[
        {"type": "web_search", "max_tokens": 2000, "max_tokens_per_page": 2000},
        {"type": "fetch_url", "max_urls": 1},
    ],
)

print(response.output_text)
```
```

--------------------------------

### Install and Build Daily News Briefing Plugin

Source: https://docs.perplexity.ai/docs/cookbook/showcase/daily-news-briefing

Clone the repository, install dependencies, and build the plugin using npm commands.

```bash
# Clone the repository
git clone https://github.com/ChenziqiAdam/Daily-News-Briefing.git
cd Daily-News-Briefing

# Install dependencies
npm install

# Build the plugin
npm run build
```

--------------------------------

### Generate Full Research Brief for NVIDIA

Source: https://docs.perplexity.ai/docs/cookbook/examples/equity-research-brief/README

Run the script with a ticker symbol to generate a comprehensive research brief. This is the quick start example.

```bash
./equity_research_brief.py NVDA
```

--------------------------------

### TypeScript Batch Research with Concurrency

Source: https://docs.perplexity.ai/docs/cookbook/articles/async-deep-research/README

This TypeScript snippet demonstrates concurrent batch research using the Perplexity SDK. It employs a worker pattern with a queue to manage concurrent requests, similar to the Python example. Ensure you have the `@perplexity-ai/perplexity_ai` package installed (`npm install @perplexity-ai/perplexity_ai`).

```typescript
import Perplexity from '@perplexity-ai/perplexity_ai';

interface ResearchResult {
  query: string;
  content?: string;
  model?: string;
  elapsed: number;
  error?: string;
}

const client = new Perplexity();

async function singleResearch(query: string): Promise<ResearchResult> {
  const start = Date.now();
  try {
    const response = await client.responses.create({
      preset: 'medium',
      input: query,
    });
    return {
      query,
      content: response.output_text,
      model: response.model,
      elapsed: (Date.now() - start) / 1000,
    };
  } catch (e) {
    return { query, error: String(e), elapsed: (Date.now() - start) / 1000 };
  }
}

async function batchResearch(queries: string[], maxConcurrent = 3) {
  const results: ResearchResult[] = [];
  const queue = [...queries];
  async function worker() {
    while (queue.length) {
      const q = queue.shift()!;
      results.push(await singleResearch(q));
    }
  }
  await Promise.all(
    Array.from({ length: maxConcurrent }, () => worker())
  );
  return results;
}

const queries = [
  'What are the latest advances in room-temperature superconductors?',
  'What is the current state of quantum error correction?',
  'What are the most promising approaches to carbon capture and storage?',
];

console.log(`Starting batch research: ${queries.length} queries\n`);
const results = await batchResearch(queries, 3);

for (const r of results) {
  const status = r.content ? 'OK' : `FAILED (${r.error})`;
  const words = r.content ? r.content.split(/\s+/).length : 0;
  console.log(`  [${r.elapsed.toFixed(0)}s] ${r.query.slice(0, 60)}... → ${status} (${words} words)`);
}

```

--------------------------------

### Install Frontend Dependencies

Source: https://docs.perplexity.ai/docs/cookbook/showcase/Ellipsis

Navigate to the frontend directory and install the necessary Node.js packages using npm.

```bash
cd ../frontend
npm install
```

--------------------------------

### Sonar API Request (TypeScript)

Source: https://docs.perplexity.ai/docs/agent-api/migrate-from-sonar/overview

Example of making a chat completion request to the Sonar API using TypeScript. Ensure the @perplexity-ai/perplexity_ai library is installed.

```typescript
import Perplexity from '@perplexity-ai/perplexity_ai';

const client = new Perplexity();

const completion = await client.chat.completions.create({
  model: 'sonar',
  messages: [{ role: 'user', content: 'What are the latest developments in AI agents?' }]
});
console.log(completion.choices[0].message.content);
```

--------------------------------

### Complete OpenAI Agent Implementation

Source: https://docs.perplexity.ai/docs/cookbook/articles/openai-agents-integration/README

This snippet shows the full setup for an asynchronous OpenAI agent. It includes importing necessary libraries, configuring the client with environment variables, defining a function tool, and running the agent with a query. Ensure you have EXAMPLE_BASE_URL, EXAMPLE_API_KEY, and EXAMPLE_MODEL_NAME set as environment variables.

```python
# Import necessary standard libraries
import asyncio  # For running asynchronous code
import os       # To access environment variables

# Import AsyncOpenAI for creating an async client
from openai import AsyncOpenAI

# Import custom classes and functions from the agents package.
# These handle agent creation, model interfacing, running agents, and more.
from agents import Agent, OpenAIChatCompletionsModel, Runner, function_tool, set_tracing_disabled

# Retrieve configuration from environment variables or use defaults
BASE_URL = os.getenv("EXAMPLE_BASE_URL") or "https://api.perplexity.ai"
API_KEY = os.getenv("EXAMPLE_API_KEY") 
MODEL_NAME = os.getenv("EXAMPLE_MODEL_NAME") or "sonar-pro"

# Validate that all required configuration variables are set
if not BASE_URL or not API_KEY or not MODEL_NAME:
    raise ValueError(
        "Please set EXAMPLE_BASE_URL, EXAMPLE_API_KEY, EXAMPLE_MODEL_NAME via env var or code."
    )

# Initialize the custom OpenAI async client with the specified BASE_URL and API_KEY.
client = AsyncOpenAI(base_url=BASE_URL, api_key=API_KEY)

# Disable tracing to avoid using a platform tracing key; adjust as needed.
set_tracing_disabled(disabled=True)

# Define a function tool that the agent can call.
# The decorator registers this function as a tool in the agents framework.
@function_tool
def get_weather(city: str):
    """
    Simulate fetching weather data for a given city.
    
    Args:
        city (str): The name of the city to retrieve weather for.
        
    Returns:
        str: A message with weather information.
    """
    print(f"[debug] getting weather for {city}")
    return f"The weather in {city} is sunny."

# Import nest_asyncio to support nested event loops
import nest_asyncio

# Apply the nest_asyncio patch to enable running asyncio.run() 
# even if an event loop is already running.
nest_asyncio.apply()

async def main():
    """
    Main asynchronous function to set up and run the agent.
    
    This function creates an Agent with a custom model and function tools,
    then runs a query to get the weather in Tokyo.
    """
    # Create an Agent instance with:
    # - A name ("Assistant")
    # - Custom instructions ("Be precise and concise.")
    # - A model built from OpenAIChatCompletionsModel using our client and model name.
    # - A list of tools; here, only get_weather is provided.
    agent = Agent(
        name="Assistant",
        instructions="Be precise and concise.",
        model=OpenAIChatCompletionsModel(model=MODEL_NAME, openai_client=client),
        tools=[get_weather],
    )

    # Execute the agent with the sample query.
    result = await Runner.run(agent, "What's the weather in Tokyo?")
    
    # Print the final output from the agent.
    print(result.final_output)

# Standard boilerplate to run the async main() function.
if __name__ == "__main__":
    asyncio.run(main())

```

--------------------------------

### Sonar API Request (Python)

Source: https://docs.perplexity.ai/docs/agent-api/migrate-from-sonar/overview

Example of making a chat completion request to the Sonar API using Python. Ensure the perplexity library is installed.

```python
from perplexity import Perplexity

client = Perplexity()

completion = client.chat.completions.create(
    model="sonar",
    messages=[{"role": "user", "content": "What are the latest developments in AI agents?"}]
)
print(completion.choices[0].message.content)
```

--------------------------------

### TypeScript Search API Example

Source: https://docs.perplexity.ai/home

Use the TypeScript SDK to perform a search query and log the titles and URLs of the results. Ensure the @perplexity-ai/perplexity_ai package is installed.

```typescript
import Perplexity from '@perplexity-ai/perplexity_ai';

const client = new Perplexity();

const search = await client.search.create({
  query: [
    "What is Comet Browser?",
    "Perplexity AI",
    "Perplexity Changelog"
  ]
});

search.results.forEach(result => {
  console.log(`${result.title}: ${result.url}`);
});
```

--------------------------------

### Launch Frontend Development Server

Source: https://docs.perplexity.ai/docs/cookbook/showcase/Ellipsis

Start the React frontend development server using npm from the frontend directory.

```bash
cd frontend
npm run dev
```

--------------------------------

### Python Example with Web Search

Source: https://docs.perplexity.ai/docs/agent-api/quickstart

Use this Python snippet to enable web search capabilities for your Agent API requests. Ensure you have the perplexity library installed.

```Python
from perplexity import Perplexity

client = Perplexity()

response = client.responses.create(
    model="openai/gpt-5.6-sol",
    input="Explain the original Transformer architecture from 'Attention Is All You Need' (Vaswani et al. 2017): encoder-decoder structure, multi-head self-attention, and positional encodings.",
    tools=[{"type": "web_search"}],
    instructions="You have access to a web_search tool. Use it for questions about current events, news, or recent developments. Use 1 query for simple questions. Keep queries brief: 2-5 words. NEVER ask permission to search - just search when appropriate",
)

if response.status == "completed":
    print(response.output_text)

```

--------------------------------

### Start LiteLLM Proxy

Source: https://docs.perplexity.ai/docs/getting-started/integrations/litellm

Launch the LiteLLM proxy server using the `litellm` command with a specified configuration file.

```bash
litellm --config /path/to/config.yaml
```

--------------------------------

### Python Preset Example

Source: https://docs.perplexity.ai/docs/agent-api/presets

Demonstrates how to create a response using the Perplexity AI SDK in Python, specifying tools and model parameters.

```python
from perplexity import Perplexity

client = Perplexity()

response = client.responses.create(
    model="openai/gpt-5.6-sol",
    input="Build a data-backed market map for AI coding agents: gather recent product launches, compare pricing and benchmarks, and use code to calculate a capability-weighted score.",
    max_steps=100,
    max_output_tokens=128000,
    reasoning={"effort": "high"},
    instructions='''
Search queries must be plain keywords. Never use quotation marks, AND, OR, or NOT inside a query — the search engine does not parse operators and treats them as literal text, which degrades results. To cover alternatives or exact phrases, send several short keyword queries instead.

# Route by intent before general research

When an available specialized or domain-specific tool authoritatively covers the user\'s intent, prefer it over generic `pplx_sdk` or web search. Fall back to web research only when no specialized tool covers the request or the specialized tool returns no relevant data.

# Mandatory for general research: load the `pplx_sdk` skill first

For research not covered by a specialized tool, before doing anything else for the user\'s task, call `load_skill({"name":"pplx_sdk"})` and read the returned SKILL.md plus any sub-docs (`patterns/`, `recipes/`, `reference/`) that are relevant to the task. The skill is the expansive Python codesearch guide for `pplx_sdk` — multi-index search, content fetch / snippets, LLM extraction, parallel fan-out, multi-step pipelines, checkpoint-resumable workflows, and recipes (people research, etc.). Reading it is mandatory, not advisory.

After reading SKILL.md, you MUST use the `pplx_sdk` Python package and the codesearch patterns the skill documents — faithful to the machinery and the spirit. When the task calls for multiple search queries, parallel fetches, or LLM extraction over many items, use the skill\'s fan-out / multi-step / checkpoint patterns rather than naive loops or hand-rolled `requests` scrapers. Read the relevant `patterns/*.md` and `reference/*.md` before writing code; consult `recipes/*.md` for full-workflow templates when applicable.

Then proceed with the user\'s task using what you just learned.''',
    tools=[
        {"type": "web_search"},
        {"type": "finance_search"},
        {"type": "sandbox"},
    ],
)

print(response.output_text)

```
Tokens:
Raw