SDKs & clients

from openai import OpenAI

client = OpenAI(
    api_key="<your ozk_ key>",
    base_url="https://api.plungeai.com/v1",
    default_headers={"x-trace-id": "00000000-0000-4000-8000-000000000006"},  # optional UUID
)
resp = client.chat.completions.create(
    model="anthropic/claude-sonnet-4-6",
    messages=[{"role": "user", "content": "Reply with exactly the word: pong"}],
    max_tokens=16,
)

import OpenAI from 'openai'

const client = new OpenAI({
  apiKey: process.env.PLUNGE_API_KEY,
  baseURL: 'https://api.plungeai.com/v1',
  defaultHeaders: { 'x-trace-id': crypto.randomUUID() }, // optional
})

import PlungeAI from '@plungeai/one-api'

const client = new PlungeAI()

const me = await client.whoami()
const run = await client.agents.execute('one-agent', { prompt: 'Reply with exactly the word: pong', max_tokens: 32 })
const hits = await client.discovery.search({ q: 'web search', kind: 'agents', limit: 3 })

const stream = await client.workflows.executeInlineStream({ workflow }) // workflow: CNL YAML string
for await (const event of stream) console.log(event.event, event.data)

for await (const w of client.workflows.list()) console.log(w) // walks every page

try {
  await client.agents.execute('no-such-agent', { prompt: 'hi' })
} catch (err) {
  if (err instanceof PlungeAI.NotFoundError) console.log(err.status, err.code, err.requestID)
  else throw err
}

from plungeai import PlungeAI, NotFoundError

client = PlungeAI()  # or AsyncPlungeAI() — same methods, awaited

me = client.whoami()
run = client.agents.execute("one-agent", prompt="Reply with exactly the word: pong", max_tokens=32)
hits = client.discovery.search(q="web search", kind="agents", limit=3)

stream = client.workflows.execute_inline_stream(workflow=workflow)  # workflow: CNL YAML string
for event in stream:
    print(event.event, event.data)

for w in client.workflows.list():  # walks every page
    print(w)

try:
    client.agents.execute("no-such-agent", prompt="hi")
except NotFoundError as err:
    print(err.status_code, err.code, err.request_id)

import (
    "context"
    "errors"
    "fmt"

    "github.com/PlungeAI/plungeai-go"
)

client := plungeai.NewClient() // plungeai.WithAPIKey(…) to override PLUNGEAI_API_KEY
ctx := context.Background()

me, err := client.Whoami(ctx)
run, err := client.Agents.Execute(ctx, "one-agent", plungeai.AgentExecuteParams{Prompt: "Reply with exactly the word: pong", MaxTokens: plungeai.Int(32)})
hits, err := client.Discovery.Search(ctx, plungeai.DiscoverySearchParams{Q: "web search", Kind: "agents", Limit: plungeai.Int(3)})

stream, err := client.Workflows.ExecuteInlineStream(ctx, plungeai.WorkflowExecuteInlineStreamParams{Workflow: workflow})
for stream.Next() {
    ev := stream.Current()
    fmt.Println(ev.Event, ev.Data)
}
err = stream.Err()

pager := client.Workflows.ListAutoPaging(ctx, plungeai.WorkflowListParams{}) // walks every page
for pager.Next() {
    fmt.Println(pager.Current())
}

_, err = client.Agents.Execute(ctx, "no-such-agent", plungeai.AgentExecuteParams{Prompt: "hi"})
var apiErr *plungeai.Error
if errors.As(err, &apiErr) && apiErr.StatusCode == 404 {
    fmt.Println(apiErr.StatusCode, apiErr.Code, apiErr.RequestID)
}

use futures_util::StreamExt;
use plungeai::{types::*, Client};

let client = Client::new()?; // or Client::builder().api_key(…).build()?

let me = client.whoami().await?;
let run = client
    .agents()
    .execute("one-agent", &AgentExecuteParams { prompt: Some("Reply with exactly the word: pong".into()), max_tokens: Some(32), ..Default::default() })
    .await?;
let hits = client.discovery().search(&DiscoverySearchParams { q: Some("web search".into()), kind: Some(DiscoverySearchParamsKind::Agents), limit: Some(3), ..Default::default() }).await?;

let mut stream = client.workflows().execute_inline_stream(&WorkflowExecuteInlineStreamParams { workflow: workflow.into(), ..Default::default() }).await?;
while let Some(event) = stream.next().await {
    let event = event?;
    println!("{:?} {}", event.event, event.data);
}

let mut items = client.workflows().list(&Default::default()).await?.into_stream(); // walks every page
while let Some(w) = items.next().await {
    println!("{:?}", w?);
}

match client.agents().execute("no-such-agent", &AgentExecuteParams { prompt: Some("hi".into()), ..Default::default() }).await {
    Err(e) if e.is_not_found() => println!("{:?} {:?}", e.status(), e.request_id()),
    other => { other?; }
}

import litellm
resp = litellm.completion(
    model="openai/anthropic/claude-sonnet-4-6",  # openai/ tells LiteLLM to use the OpenAI wire
    api_base="https://api.plungeai.com/v1",
    api_key="<your ozk_ key>",
    messages=[{"role": "user", "content": "pong?"}],
)

import { createOpenAI } from '@ai-sdk/openai'

const ocean = createOpenAI({
  baseURL: 'https://api.plungeai.com/v1',
  apiKey: process.env.PLUNGE_API_KEY,
})
const model = ocean('anthropic/claude-sonnet-4-6')

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="anthropic/claude-sonnet-4-6",
    base_url="https://api.plungeai.com/v1",
    api_key="<your ozk_ key>",
)

claude mcp add --transport http plungeai https://api.plungeai.com/v1/mcp \
  --header "Authorization: Bearer $PLUNGE_API_KEY"

{
  "mcpServers": {
    "plungeai": {
      "command": "npx",
      "args": ["mcp-remote", "https://api.plungeai.com/v1/mcp",
               "--header", "Authorization: Bearer ${PLUNGE_API_KEY}"]
    }
  }
}

curl -s -X POST https://api.plungeai.com/v1/mcp \
  -H "Authorization: Bearer $PLUNGE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","method":"tools/list","id":1}'

curl -s "https://api.plungeai.com/v1/agents?limit=3" \
  -H "Authorization: Bearer $PLUNGE_API_KEY"