Standard Operating Procedures

• Create, train, test, and publish agents (own models plus Bedrock and Ollama)
• 16+ built-in tools, including image, video, and speech generation
• Video: text_to_video, image_to_video, combine_video_audio
• Speech: text_to_speech for narration and videos with sound
• Media tools run only when the user actually asks for an image, video, or voiceover—short replies like “A” or “Done” stay text
• MCP servers for extra tools; RAG from uploaded training data
• In-app chat with background polling (you never see “Please poll again”)
• REST API and agent webhooks for Zapier, n8n, Make, cron, and pipelines
• Public marketplace, email sharing, and public share URLs
• Pay-as-you-go credits — new accounts get 200 welcome credits
• Contact / demo forms, plus WhatsApp technical support

1. Navigate to your agent's training page: /dashboard/{agent_id}/train/
2. Scroll to the "Tools Configuration" section
3. You'll see three categories:
   • Default Tools - Built-in system tools
   • Custom Tools - Your custom HTTP-based tools
   • MCP Tools - Tools from connected MCP servers
4. Toggle tools on/off using the checkboxes
5. Click "Save Tool Configuration" to apply changes

PATCH /api/agents/{agent_id}/
Authorization: Bearer YOUR_USER_TOKEN
Content-Type: application/json

{
  "configuration": {
    "enabled_tools": ["web_search", "url_resolver", "code_executor"],
    "disabled_tools": []
  }
}

PATCH /api/agents/{agent_id}/
Authorization: Bearer YOUR_USER_TOKEN
Content-Type: application/json

{
  "configuration": {
    "disabled_tools": ["text_to_image", "transcription"]
  }
}

{
  "configuration": {
    "use_rag": true,
    "rag_top_k": 5,
    "rag_threshold": 0.7
  }
}

• use_rag: Enable/disable RAG feature
• rag_top_k: Number of relevant chunks to retrieve (default: 5)
• rag_threshold: Similarity threshold for retrieval (default: 0.7)

{
  "configuration": {
    "tools_enabled": true,
    "max_tool_iterations": 10
  }
}

• tools_enabled: Enable/disable tool calling capability
• max_tool_iterations: Maximum tool call iterations (default: 10)

{
  "configuration": {
    "use_memory": true,
    "max_history_messages": 50
  }
}

• use_memory: Enable conversation memory
• max_history_messages: Maximum messages to keep in context

• Via Dashboard: Go to agent training page → Tools Configuration section
• Via API: GET /api/agents/{agent_id}/ → Check configuration.enabled_tools and configuration.disabled_tools

• POST /auth/register/ — username, email, password → access + refresh + user
• POST /auth/login/ — username or email + password → tokens
• POST /auth/refresh/ — {"refresh": "..."} → new access (and rotated refresh)
• POST /auth/logout/ — blacklist refresh (Bearer required)
• GET /auth/me/ — current user profile

• GET /agents/public/ — paginated public agents (?search=)
• GET /agents/public/{slug}/ — detail
• POST /agents/public/{slug}/like/ — feedback_type: like | dislike | clear

• POST /chat/send/ — agent_slug or agent_id, message, optional conversation_id → 202 with task_id
• GET /chat/tasks/{task_id}/ — poll until success / failure
• GET /chat/conversations/, detail, messages, delete
• POST /chat/upload/, POST /chat/feedback/

• GET /credits/balance/, GET /credits/packages/ (checkout remains web /dashboard/credits/)
• GET|PATCH /profile/
• GET /notifications/, POST /notifications/mark-read/

• GET /api/agents/ - List all user's agents
• POST /api/agents/ - Create new agent
• GET /api/agents/{id}/ - Get agent details
• PATCH /api/agents/{id}/ - Update agent
• DELETE /api/agents/{id}/ - Delete agent
• POST /api/agents/{id}/publish/ - Publish agent
• POST /api/agents/{id}/unpublish/ - Unpublish agent

• POST /api/agents/{id}/chat/ - Chat with agent
• POST /api/agents/{id}/query/ - Query agent
• POST /api/agents/{id}/invoke/ - Invoke agent action
• GET /api/agents/{id}/status/ - Get agent status
• GET /api/agents/{id}/history/ - Get interaction history

POST /api/agents/
Authorization: Bearer YOUR_USER_API_KEY
Content-Type: application/json

{
  "name": "Customer Support Bot",
  "description": "Helps customers with common questions",
  "model_id": 1,
  "agent_type": "quick_bot",
  "configuration": {
    "system_prompt": "You are a helpful customer support assistant.",
    "enabled_tools": ["web_search", "url_resolver"],
    "use_rag": true
  }
}

POST /api/agents/{agent_id}/chat/
Authorization: ApiKey YOUR_AGENT_API_KEY
Content-Type: application/json

{
  "message": "What is the weather today?",
  "conversation_id": "optional-conversation-id"
}

{
  "response": "I'll search for today's weather information...",
  "tool_calls": [
    {
      "tool_name": "web_search",
      "parameters": {"query": "weather today"},
      "result": "..."
    }
  ],
  "conversation_id": "conv-123",
  "iterations": 2
}

• POST /api/v1/chat - Sync chat (agent key, or user key + agent_slug/agent_id)
• POST /api/v1/query - Sync query (same auth rules as chat)
• GET /api/v1/agents - List accessible agents (agent API key)
• GET /api/v1/agents/{id} - Get agent info (agent API key)

Your own agent (agent API key — owner billed):

POST /api/v1/chat
Authorization: ApiKey YOUR_AGENT_API_KEY
Content-Type: application/json

{
  "message": "Hello, how can you help me?"
}

Public marketplace agent (user API key — caller billed + owner revenue share):

POST /api/v1/chat
Authorization: ApiKey YOUR_USER_API_KEY
Content-Type: application/json

{
  "message": "Hello, how can you help me?",
  "agent_slug": "doctor-rahul"
}

{
  "response": "Hello! I can help you with...",
  "tool_calls": [],
  "iterations": 1,
  "conversation_id": "conv-abc123",
  "agent_id": 42,
  "agent_slug": "doctor-rahul"
}

Tip: On the Agent Marketplace, open Use Via API on any card for copy-ready curls. Manage keys under Profile → User API keys.

• POST /api/create_conversation - Create conversation (user key requires agent_slug or agent_id)
• POST /api/continue_conversation - Continue (your conversations only when using a user key)
• GET /api/get_answer - Poll by request_id
• POST /api/find_conversation - Conversation history
• POST /api/webhook/agent/ - Agent webhook (agent API key only; see §5.3.5)
• GET /api/public_profile?email= or POST /api/public_profile — public GenAI resume profile by email (no auth)
• PUT /api/upload_file / GET /api/download_file — files (agent API key)
• POST /api/create_upload_url / POST /api/get_download_url — signed URLs (agent API key)

POST /api/create_conversation
Authorization: ApiKey YOUR_AGENT_API_KEY
Content-Type: application/json

{
  "message": "What is machine learning?"
}

Public agent (user API key — caller pays + owner revenue share):

POST /api/create_conversation
Authorization: ApiKey YOUR_USER_API_KEY
Content-Type: application/json

{
  "message": "What is machine learning?",
  "agent_slug": "doctor-rahul"
}

{
  "request_id": "req-550e8400-e29b-41d4-a716",
  "conversation_id": "conv-550e8400-e29b-41d4-a716",
  "status": "pending"
}

GET /api/get_answer?request_id=req-550e8400-e29b-41d4-a716
Authorization: ApiKey YOUR_AGENT_API_KEY
# or YOUR_USER_API_KEY if you created the conversation as a caller

POST /api/continue_conversation
Authorization: ApiKey YOUR_AGENT_API_KEY
Content-Type: application/json

{
  "conversation_id": "conv-550e8400-e29b-41d4-a716",
  "message": "Tell me more about that"
}

With a user API key, you may only continue / poll / find conversations where conversation.user is you (the caller who created them).

• User API key from Profile → User API keys
• Published agent with an active public share
• Body field agent_slug or agent_id on sync chat and create_conversation
• Positive credit balance on the caller’s account (HTTP 402 if insufficient)

POST /api/v1/chat
Authorization: ApiKey YOUR_USER_API_KEY
{"message": "Hello", "agent_slug": "doctor-rahul"}

POST /api/create_conversation
Authorization: ApiKey YOUR_USER_API_KEY
{"message": "Hello", "agent_slug": "doctor-rahul"}
→ poll GET /api/get_answer?request_id=...
→ POST /api/continue_conversation {"conversation_id": "...", "message": "..."}

Authorization: ApiKey YOUR_AGENT_API_KEY

Alternative header:

X-API-Key: YOUR_AGENT_API_KEY

• The agent must be published. Draft, training, and testing agents reject agent API key calls.
• Every successful POST starts a new conversation. Webhook calls do not continue each other automatically. To send a follow-up in the same thread, use POST /api/continue_conversation with the conversation_id returned in the webhook response.
• Processing is asynchronous. Poll GET /api/get_answer?request_id=... until status is completed or failed. See §7 Async Requests & Polling.

• At least one of message, text, or payload is required.
• message or text: natural-language instruction (either key; if both are set, message wins).
• payload: optional JSON object. Appended to the composed user message under a [Webhook payload] section so tools and RAG see structured caller data (ticket ids, CRM fields, webhook event bodies, etc.).
• metadata: optional JSON object. Not sent to the model; echoed back in the HTTP 202 response for correlation (trace_id, upstream job id, Zapier run id, etc.).

POST /api/webhook/agent/
Authorization: ApiKey YOUR_AGENT_API_KEY
Content-Type: application/json

{
  "message": "Summarize this inbound event for the team.",
  "payload": {
    "event": "ticket.created",
    "ticket_id": "TKT-4412",
    "priority": "high"
  },
  "metadata": {
    "trace_id": "run-2026-04-27-001",
    "source": "zendesk"
  }
}

{
  "request_id": "550e8400-e29b-41d4-a716-446655440000",
  "conversation_id": "660e8400-e29b-41d4-a716-446655440001",
  "agent_id": 123,
  "status": "pending",
  "metadata": {
    "trace_id": "run-2026-04-27-001",
    "source": "zendesk"
  }
}

Do not display this JSON (or any poll payload) as a chat message. Keep polling until status is completed or failed.

GET /api/get_answer?request_id=550e8400-e29b-41d4-a716-446655440000
Authorization: ApiKey YOUR_AGENT_API_KEY

• 202 + status: pending or processing — keep polling in the background (1–2s, with backoff). These responses have no user-facing answer; do not print them in chat or as the next user message.
• 200 + status: completed — includes answer, tool_calls, iterations, conversation_id, created_at. Show answer only.
• 200 + status: failed — includes error (agent loop, tools, or insufficient credits). Stop polling; this is not an HTTP outage.
• 404 — unknown request_id for this agent.
• 403 — missing/invalid API key or agent not published.
• 402 on enqueue — agent owner lacks minimum credits; the request is not queued.

import time
import requests

BASE = "https://your-domain.com/api"
HEADERS = {
    "Authorization": "ApiKey YOUR_AGENT_API_KEY",
    "Content-Type": "application/json",
}

enqueue = requests.post(
    f"{BASE}/webhook/agent/",
    headers=HEADERS,
    json={
        "message": "Triage this support ticket.",
        "payload": {"ticket_id": "TKT-99", "subject": "Billing issue"},
        "metadata": {"trace_id": "zapier-run-42"},
    },
    timeout=30,
)
enqueue.raise_for_status()
body = enqueue.json()
request_id = body["request_id"]
conversation_id = body["conversation_id"]

while True:
    poll = requests.get(
        f"{BASE}/get_answer",
        headers=HEADERS,
        params={"request_id": request_id},
        timeout=30,
    )
    data = poll.json()
    status = data.get("status")
    if status in ("pending", "processing"):
        time.sleep(1.5)
        continue
    if status == "completed":
        print(data["answer"])
        break
    raise RuntimeError(data.get("error") or data)

• GET /api/mcp-servers/ - List MCP servers
• POST /api/mcp-servers/ - Create MCP server
• GET /api/mcp-servers/{id}/ - Get server details
• PUT /api/mcp-servers/{id}/ - Update server
• DELETE /api/mcp-servers/{id}/ - Delete server
• POST /api/mcp-servers/{id}/test_connection/ - Test connection
• GET /api/mcp-servers/list_tools/?agent_id={id} - List available tools

POST /api/mcp-servers/
Authorization: Bearer YOUR_USER_API_KEY
Content-Type: application/json

{
  "agent": 1,
  "name": "filesystem",
  "description": "Local filesystem access",
  "transport_type": "stdio",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
  "auto_connect": true
}

Authorization: ApiKey YOUR_USER_API_KEY
# also accepted:
Authorization: Bearer YOUR_USER_API_KEY
X-API-Key: YOUR_USER_API_KEY

Authorization: ApiKey YOUR_AGENT_API_KEY

X-API-Key: YOUR_AGENT_API_KEY

{
  "request_id": "req-550e8400-e29b-41d4-a716",
  "conversation_id": "conv-550e8400-e29b-41d4-a716",
  "status": "pending"
}

Note: The conversation_id is now returned immediately when creating a conversation, allowing you to maintain chat context across multiple API calls.

import requests

# Configuration
BASE_URL = "https://your-domain.com/api"
AGENT_API_KEY = "your-agent-api-key"

# Chat with agent
response = requests.post(
    f"{BASE_URL}/v1/chat",
    headers={
        "Authorization": f"ApiKey {AGENT_API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "message": "What is artificial intelligence?"
    }
)

result = response.json()
print(f"Response: {result['response']}")
print(f"Tool calls: {result.get('tool_calls', [])}")

Replace the agent key with a user API key and add agent_slug in the create body to call a public marketplace agent (caller billed + owner revenue share).

const API_KEY = "your-agent-api-key";
const BASE_URL = "https://your-domain.com/api";

// Create conversation (async)
const createResponse = await fetch(`${BASE_URL}/create_conversation`, {
  method: 'POST',
  headers: {
    'Authorization': `ApiKey ${API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    message: "Hello, agent!"
    // For public agents with a user API key, also pass:
    // agent_slug: "doctor-rahul"
  })
});

const { request_id, conversation_id } = await createResponse.json();

// Store conversation_id for maintaining context
console.log('Conversation ID:', conversation_id);

// Poll for results
const pollAnswer = async () => {
  const response = await fetch(
    `${BASE_URL}/get_answer?request_id=${request_id}`,
    {
      headers: { 'Authorization': `ApiKey ${API_KEY}` }
    }
  );
  return response.json();
};

// Poll until completed
let result = await pollAnswer();
while (result.status === 'pending' || result.status === 'processing') {
  await new Promise(resolve => setTimeout(resolve, 1000));
  result = await pollAnswer();
}

console.log('Final response:', result.response);

// Continue the conversation using conversation_id
const continueResponse = await fetch(`${BASE_URL}/continue_conversation`, {
  method: 'POST',
  headers: {
    'Authorization': `ApiKey ${API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    conversation_id: conversation_id,
    message: "Tell me more about that"
  })
});

const continueResult = await continueResponse.json();
console.log('Continued conversation response:', continueResult);

curl -X POST https://your-domain.com/api/agents/1/chat/ \
  -H "Authorization: ApiKey YOUR_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello"}'

curl -X POST https://your-domain.com/api/v1/chat \
  -H "Authorization: ApiKey YOUR_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello"}'

curl -X POST https://your-domain.com/api/v1/chat \
  -H "Authorization: ApiKey YOUR_USER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello", "agent_slug": "doctor-rahul"}'

curl -X GET https://your-domain.com/api/mcp-servers/list_tools/?agent_id=1 \
  -H "Authorization: Bearer YOUR_USER_API_KEY"

• request_id — poll for this turn’s result
• conversation_id — returned immediately; use it with /api/continue_conversation for follow-ups even while the first turn is still running

{
  "agent": 1,
  "name": "filesystem",
  "description": "Local filesystem access",
  "transport_type": "stdio",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
  "auto_connect": true
}

• JIRA - Atlassian JIRA Cloud (OAuth 2.0 3LO)
• Confluence - Atlassian Confluence (OAuth 2.0 3LO)
• GitLab - GitLab repositories (OAuth 2.0)
• GitHub - GitHub repositories (OAuth 2.0)
• Google - Google Workspace (Drive, Docs, Sheets, Gmail) (OAuth 2.0)
• Microsoft - Microsoft 365 (OneDrive, SharePoint, Outlook, Teams) (OAuth 2.0)
• Slack - Slack workspace (OAuth 2.0) - Coming soon

• Replace {connector_id} with the actual connector ID after creating the connector
• The callback URL is provided in the API response when creating a connector
• The URL must match EXACTLY (including protocol, domain, path, and trailing slash)

• https://example.com/api/connectors/1/oauth/callback/ (JIRA connector #1)
• https://example.com/api/connectors/2/oauth/callback/ (GitHub connector #2)
• https://example.com/api/connectors/3/oauth/callback/ (Google connector #3)
• https://example.com/api/connectors/4/oauth/callback/ (Microsoft connector #4)

• Create Connector: POST /api/connectors/ (returns callback_url)
• Initiate OAuth: POST /api/connectors/{connector_id}/oauth/initiate/ (returns callback_url)
• OAuth Callback: GET /api/connectors/{connector_id}/oauth/callback/ (handled automatically)

1. Navigate to your published agent's detail page
2. Click "Share Agent (Email)" button
3. Enter recipient's email address
4. Optionally add a message and set expiration
5. An email with a unique share link is sent to the recipient
6. Recipient clicks the link and accepts the share
7. They can now access and use your agent

• email - Recipient's email address (required)
• message - Optional message to include
• expires_days - Optional expiration in days

• Resend Email: Resend share invitation email
• Withdraw Share: Remove pending invitations
• Revoke Access: Remove access from accepted shares

1. Navigate to your published agent's detail page
2. Click "Public Share URL" button
3. Optionally set expiration date
4. Copy the generated share URL
5. Share the URL with anyone (via email, social media, website, etc.)
6. Anyone with the URL can access your agent (after login/registration)

1. Go to agent detail page: /dashboard/{agent_id}/
2. Click "Public Share URL" button
3. Set optional expiration (in days)
4. Click "Generate Share URL"
5. Copy the generated URL

{
  "expires_days": 30  // Optional: expiration in days
}

• Unique token for each share
• Accessible by anyone with the URL
• Requires user login/registration to use
• Automatically redirects to agent chat after authentication

• Active public share URL is displayed on agent detail page
• Shows access count and last accessed time
• Shows expiration date if set

• Click "Deactivate" button on agent detail page
• Or use API: POST /dashboard/{agent_id}/public-share/deactivate/
• Deactivated URLs no longer grant access

POST /dashboard/{agent_id}/public-share/
Authorization: Session or User API Key
Content-Type: application/json

{
  "expires_days": 30
}

{
  "success": true,
  "share_url": "https://your-domain.com/dashboard/public/{token}/",
  "expires_at": "2024-02-15T00:00:00Z"
}

• Free Tier: Basic features with daily limits
• Starter: Increased limits for individuals
• Professional: Advanced features for teams
• Enterprise: Unlimited features for organizations
• Pay-As-You-Go: Flexible usage-based pricing with no monthly commitment

• Message (chat): 3 credits per message
• API call (REST): 0.08 credits per /api/v1/chat or /api/v1/query call (agent owner is billed)
• Tool call: 0.15 credits per tool execution
• Storage: 0.002 credits per MB
• Agent creation: 1.5 credits per agent
• Video generation: 30–75 credits depending on duration and model (text_to_video, image_to_video)

Welcome credits: New accounts receive 200 credits on first login. Usage is deducted from that balance; buy more anytime.

REST API: Agent API key → agent owner is charged. User API key + public agent_slug → caller is charged and the owner receives revenue share (same as marketplace chat). Insufficient credits return 402.

• Messages: Chat messages sent to agents
• Tool Calls: Tools executed by agents
• API Calls: API requests made
• Storage: File storage used (in MB)
• Agent Creations: Number of agents created

• Click "Analytics" in the header navigation
• View real-time usage statistics
• See usage by metric type
• Monitor remaining limits
• Track usage trends

1. Navigate to Credits section in header
2. View current credit balance
3. Purchase additional credits
4. Monitor credit usage
5. Set up auto-recharge (coming soon)

Oshaani Social (social.oshaani.com) is a dedicated social platform where users can:

• Share AI Agents: Publish your created agents and showcase them to the community
• Discover Agents: Browse and discover innovative AI agents created by others
• Build Communities: Connect with other developers and AI enthusiasts
• Collaborate: Work together on AI projects and share knowledge
• Get Feedback: Receive community feedback on your AI creations
• Learn: Access tutorials, best practices, and use cases

• Complete toolchain from creation to deployment to sharing
• Community support and knowledge sharing
• Access to pre-built agents and templates
• Learning resources and best practices

• Professional AI agent creation platform
• Scalable deployment options
• Enterprise-grade security and reliability
• Integration with existing tools and workflows

• Showcase your AI creations
• Build a following and reputation
• Monetization opportunities (coming soon)
• Collaboration with other creators

• Developer Tools: Advanced APIs, SDKs, and developer resources
• Marketplace: Buy and sell AI agents and templates
• Analytics Dashboard: Enhanced analytics across platforms
• Mobile Apps: iOS and Android applications
• Enterprise Features: Advanced security, SSO, and team management
• Auto-Recharge: Automatic credit top-up when balance is low
• Team Sharing: Share agents with entire teams or organizations