Agent Completions Reference

const response = await fetch('https://api.swarms.world/v1/agent/completions', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'your-api-key'
    },
    body: JSON.stringify({
        agent_config: {
            agent_name: "Streaming Agent",
            model_name: "gpt-4.1-mini",
            max_tokens: 1024,
            streaming_on: true
        },
        task: "Write a haiku about distributed systems"
    })
});

const reader = response.body!.getReader();
const decoder = new TextDecoder();
let event: string | null = null;
let buffer = "";

while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });

    let lineEnd: number;
    while ((lineEnd = buffer.indexOf("\n")) >= 0) {
        const line = buffer.slice(0, lineEnd).trim();
        buffer = buffer.slice(lineEnd + 1);
        if (!line) continue;
        if (line.startsWith("event:")) {
            event = line.slice(6).trim();
        } else if (line.startsWith("data:")) {
            const data = JSON.parse(line.slice(5).trim());
            if (event === "chunk") process.stdout.write(data.content);
            if (event === "usage") console.log("\nusage:", data);
        }
    }
}

const payload = {
    agent_config: {
        agent_name: "Research Analyst",
        description: "Expert in analyzing and synthesizing research data",
        system_prompt: "You are a Research Analyst with expertise in data analysis and synthesis.",
        model_name: "gpt-4.1-mini",
        max_tokens: 8192,
        temperature: 0.7
    },
    task: "Analyze the impact of artificial intelligence on healthcare"
};

const response = await fetch('https://api.swarms.world/v1/agent/completions', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'your-api-key'
    },
    body: JSON.stringify(payload)
});

const result = await response.json();

use reqwest;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    
    let payload = json!({
        "agent_config": {
            "agent_name": "Research Analyst",
            "description": "Expert in analyzing and synthesizing research data",
            "system_prompt": "You are a Research Analyst with expertise in data analysis and synthesis.",
            "model_name": "gpt-4.1-mini",
            "max_tokens": 8192,
            "temperature": 0.7
        },
        "task": "Analyze the impact of artificial intelligence on healthcare"
    });

    let response = client
        .post("https://api.swarms.world/v1/agent/completions")
        .header("x-api-key", "your-api-key")
        .json(&payload)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{:?}", result);
    
    Ok(())
}

const payload = {
    agent_config: {
        agent_name: "Medical Assistant",
        system_prompt: "You are a medical information assistant.",
        model_name: "gpt-4.1-mini",
        max_tokens: 4096
    },
    task: "What are the symptoms of diabetes?",
    history: {
        message1: {
            role: "user",
            content: "Tell me about diabetes"
        },
        message2: {
            role: "assistant",
            content: "Diabetes is a chronic condition affecting blood sugar levels."
        }
    }
};

use serde_json::json;

let payload = json!({
    "agent_config": {
        "agent_name": "Medical Assistant",
        "system_prompt": "You are a medical information assistant.",
        "model_name": "gpt-4.1-mini",
        "max_tokens": 4096
    },
    "task": "What are the symptoms of diabetes?",
    "history": {
        "message1": {
            "role": "user",
            "content": "Tell me about diabetes"
        },
        "message2": {
            "role": "assistant",
            "content": "Diabetes is a chronic condition affecting blood sugar levels."
        }
    }
});

const payload = {
    agent_config: {
        agent_name: "Research Assistant",
        description: "Research assistant with web search capabilities",
        system_prompt: "You are a research assistant that can search the web.",
        model_name: "gpt-4.1-mini",
        max_tokens: 8192
    },
    task: "Find the latest developments in quantum computing",
    tools_enabled: ["auto_search"]
};

use serde_json::json;

let payload = json!({
    "agent_config": {
        "agent_name": "Research Assistant",
        "description": "Research assistant with web search capabilities",
        "system_prompt": "You are a research assistant that can search the web.",
        "model_name": "gpt-4.1-mini",
        "max_tokens": 8192
    },
    "task": "Find the latest developments in quantum computing",
    "tools_enabled": ["auto_search"]
});

const payload = {
    agent_config: {
        agent_name: "Data Analyst",
        description: "Data analyst with database access",
        system_prompt: "You are a data analyst with access to databases.",
        model_name: "gpt-4.1-mini",
        max_tokens: 8192,
        mcp_url: "http://github.com/mcp"
    },
    task: "Query the customer database for recent orders"
};

use serde_json::json;

let payload = json!({
    "agent_config": {
        "agent_name": "Data Analyst",
        "description": "Data analyst with database access",
        "system_prompt": "You are a data analyst with access to databases.",
        "model_name": "gpt-4.1-mini",
        "max_tokens": 8192,
        "mcp_url": "http://github.com/mcp"
    },
    "task": "Query the customer database for recent orders"
});

const payload = {
    agent_config: {
        agent_name: "Creative Writer",
        description: "Creative writing specialist",
        system_prompt: "You are a creative writing expert.",
        model_name: "gpt-4.1",
        max_tokens: 2048,
        temperature: 0.9,
        llm_args: {
            top_p: 0.9,
            frequency_penalty: 0.1,
            presence_penalty: 0.1
        }
    },
    task: "Write a creative story about time travel"
};

use serde_json::json;

let payload = json!({
    "agent_config": {
        "agent_name": "Creative Writer",
        "description": "Creative writing specialist",
        "system_prompt": "You are a creative writing expert.",
        "model_name": "gpt-4.1",
        "max_tokens": 2048,
        "temperature": 0.9,
        "llm_args": {
            "top_p": 0.9,
            "frequency_penalty": 0.1,
            "presence_penalty": 0.1
        }
    },
    "task": "Write a creative story about time travel"
});

const payload = {
    agent_config: {
        agent_name: "Invoice Extractor",
        description: "Extracts structured invoice data from raw text",
        system_prompt: "You extract invoice fields from documents. Always respond using the provided tool schema.",
        model_name: "gpt-4o",
        max_tokens: 1024,
        temperature: 0.1,
        tools_list_dictionary: [
            {
                type: "function",
                function: {
                    name: "extract_invoice",
                    description: "Extract structured fields from an invoice",
                    parameters: {
                        type: "object",
                        properties: {
                            vendor: { type: "string", description: "Vendor or supplier name" },
                            invoice_number: { type: "string", description: "Invoice identifier" },
                            total_amount: { type: "number", description: "Total amount due in USD" },
                            due_date: { type: "string", description: "Payment due date, ISO 8601" }
                        },
                        required: ["vendor", "invoice_number", "total_amount"]
                    }
                }
            }
        ]
    },
    task: "Invoice ACME-2024-001 from Acme Corp: total $4,250.00, due 2026-08-01"
};

use serde_json::json;

let payload = json!({
    "agent_config": {
        "agent_name": "Invoice Extractor",
        "description": "Extracts structured invoice data from raw text",
        "system_prompt": "You extract invoice fields from documents. Always respond using the provided tool schema.",
        "model_name": "gpt-4o",
        "max_tokens": 1024,
        "temperature": 0.1,
        "tools_list_dictionary": [
            {
                "type": "function",
                "function": {
                    "name": "extract_invoice",
                    "description": "Extract structured fields from an invoice",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "vendor": {"type": "string", "description": "Vendor or supplier name"},
                            "invoice_number": {"type": "string", "description": "Invoice identifier"},
                            "total_amount": {"type": "number", "description": "Total amount due in USD"},
                            "due_date": {"type": "string", "description": "Payment due date, ISO 8601"}
                        },
                        "required": ["vendor", "invoice_number", "total_amount"]
                    }
                }
            }
        ]
    },
    "task": "Invoice ACME-2024-001 from Acme Corp: total $4,250.00, due 2026-08-01"
});

const payload = {
    agent_config: {
        agent_name: "Problem Solver",
        description: "Agent that performs iterative problem-solving",
        system_prompt: "You are a problem-solving agent that breaks down complex tasks into steps and iteratively refines solutions.",
        model_name: "gpt-4.1",
        max_loops: 3,
        max_tokens: 4096,
        temperature: 0.7
    },
    task: "Solve this multi-step problem: First, research the current state of renewable energy. Then, identify the top 3 challenges. Finally, propose solutions for each challenge."
};

const response = await fetch('https://api.swarms.world/v1/agent/completions', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'your-api-key'
    },
    body: JSON.stringify(payload)
});

const result = await response.json();

use reqwest;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    
    let payload = json!({
        "agent_config": {
            "agent_name": "Problem Solver",
            "description": "Agent that performs iterative problem-solving",
            "system_prompt": "You are a problem-solving agent that breaks down complex tasks into steps and iteratively refines solutions.",
            "model_name": "gpt-4.1",
            "max_loops": 3,
            "max_tokens": 4096,
            "temperature": 0.7
        },
        "task": "Solve this multi-step problem: First, research the current state of renewable energy. Then, identify the top 3 challenges. Finally, propose solutions for each challenge."
    });

    let response = client
        .post("https://api.swarms.world/v1/agent/completions")
        .header("x-api-key", "your-api-key")
        .json(&payload)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{:?}", result);
    
    Ok(())
}

const payload = {
    agent_config: {
        marketplace_prompt_id: "1191250b-9fb3-42e0-b0e9-25ec83260ab2",
        model_name: "gpt-4.1-mini",
        max_tokens: 8192
    },
    task: "Your task here"
};

const response = await fetch('https://api.swarms.world/v1/agent/completions', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'your-api-key'
    },
    body: JSON.stringify(payload)
});

const result = await response.json();

use reqwest;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    
    let payload = json!({
        "agent_config": {
            "marketplace_prompt_id": "1191250b-9fb3-42e0-b0e9-25ec83260ab2",
            "model_name": "gpt-4.1-mini",
            "max_tokens": 8192
        },
        "task": "Your task here"
    });

    let response = client
        .post("https://api.swarms.world/v1/agent/completions")
        .header("x-api-key", "your-api-key")
        .json(&payload)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{:?}", result);
    
    Ok(())
}

import * as fs from 'fs';

// Encode an image from a file
const imageBuffer = fs.readFileSync('path/to/image.jpg');
const base64Image = imageBuffer.toString('base64');

// Or encode from a URL
// const imageResponse = await fetch('https://example.com/image.jpg');
// const arrayBuffer = await imageResponse.arrayBuffer();
// const base64Image = Buffer.from(arrayBuffer).toString('base64');

const payload = {
    agent_config: {
        agent_name: "Image Analyzer",
        description: "AI agent specialized in image analysis",
        system_prompt: "You are an expert at analyzing and describing images in detail.",
        model_name: "gpt-4.1",
        max_tokens: 2048,
        temperature: 0.5
    },
    task: "Describe what you see in this image in detail",
    img: base64Image
};

const response = await fetch('https://api.swarms.world/v1/agent/completions', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'your-api-key'
    },
    body: JSON.stringify(payload)
});

const result = await response.json();
console.log(result.outputs[0].content);

use reqwest;
use serde_json::json;
use base64::{Engine as _, engine::general_purpose};
use std::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    // Encode an image from a file
    let image_bytes = fs::read("path/to/image.jpg")?;
    let base64_image = general_purpose::STANDARD.encode(&image_bytes);

    let payload = json!({
        "agent_config": {
            "agent_name": "Image Analyzer",
            "description": "AI agent specialized in image analysis",
            "system_prompt": "You are an expert at analyzing and describing images in detail.",
            "model_name": "gpt-4.1",
            "max_tokens": 2048,
            "temperature": 0.5
        },
        "task": "Describe what you see in this image in detail",
        "img": base64_image
    });

    let response = client
        .post("https://api.swarms.world/v1/agent/completions")
        .header("x-api-key", "your-api-key")
        .json(&payload)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{}", result["outputs"][0]["content"]);

    Ok(())
}

const payloads = [
    {
        agent_config: {
            agent_name: "Analyst 1",
            system_prompt: "You are a financial analyst.",
            model_name: "gpt-4.1-mini"
        },
        task: "Analyze Q1 financial results"
    },
    {
        agent_config: {
            agent_name: "Analyst 2",
            system_prompt: "You are a market analyst.",
            model_name: "gpt-4.1-mini"
        },
        task: "Evaluate market trends"
    }
];

const response = await fetch('https://api.swarms.world/v1/agent/batch/completions', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'your-api-key'
    },
    body: JSON.stringify(payloads)
});

const result = await response.json();

use reqwest;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    
    let payloads = json!([
        {
            "agent_config": {
                "agent_name": "Analyst 1",
                "system_prompt": "You are a financial analyst.",
                "model_name": "gpt-4.1-mini"
            },
            "task": "Analyze Q1 financial results"
        },
        {
            "agent_config": {
                "agent_name": "Analyst 2",
                "system_prompt": "You are a market analyst.",
                "model_name": "gpt-4.1-mini"
            },
            "task": "Evaluate market trends"
        }
    ]);

    let response = client
        .post("https://api.swarms.world/v1/agent/batch/completions")
        .header("x-api-key", "your-api-key")
        .json(&payloads)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{:?}", result);
    
    Ok(())
}

use reqwest;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    
    let payload = json!({
        "agent_config": {
            "agent_name": "Rust Agent",
            "system_prompt": "You are a helpful assistant.",
            "model_name": "gpt-4.1-mini"
        },
        "task": "Explain Rust async/await"
    });

    let response = client
        .post("https://api.swarms.world/v1/agent/completions")
        .header("x-api-key", "your-api-key")
        .json(&payload)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{:?}", result);
    
    Ok(())
}