# Replace YOUR_API_KEY with your key from above
curl -X POST https://opensource-ai-agent.uk/llm/chat \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"Hello"}],"provider":"groq"}'

{
  "text": "Hello! How can I help you today?",
  "provider": "groq",
  "model": "llama3-70b-8192",
  "usage": {
    "prompt_tokens": 12,
    "completion_tokens": 9,
    "total_tokens": 21
  }
}

Authorization: Bearer oai_your_key_here

{
  "success": false,
  "error": "Rate limit exceeded",
  "code": "RATE_LIMIT_EXCEEDED",
  "retry_after": 42
}

X-RateLimit-Limit: 60
X-RateLimit-Remaining: 47
X-RateLimit-Reset: 1746619200
X-RateLimit-Window: minute

https://opensource-ai-agent.uk/api/v1/workflows

curl -X POST https://opensource-ai-agent.uk/llm/chat \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [{"role": "user", "content": "Summarise this report: ..."}],
    "provider": "groq",
    "max_tokens": 500
  }'

{
  "text": "The report covers...",
  "provider": "groq",
  "model": "llama3-70b-8192",
  "usage": {"prompt_tokens": 45, "completion_tokens": 120, "total_tokens": 165}
}

curl "https://opensource-ai-agent.uk/api/blockchain/price?coins=bitcoin,ethereum¤cy=usd" \
  -H "Authorization: Bearer YOUR_API_KEY"

{
  "success": true,
  "prices": {
    "bitcoin": {"usd": 65432.10, "usd_24h_change": 2.34},
    "ethereum": {"usd": 3456.78, "usd_24h_change": 1.87}
  },
  "currency": "usd"
}

import requests

API_KEY = "oai_your_key_here"
BASE_URL = "https://opensource-ai-agent.uk"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

# Chat with AI
response = requests.post(
    f"{BASE_URL}/llm/chat",
    headers=headers,
    json={
        "messages": [{"role": "user", "content": "Hello"}],
        "provider": "groq",
        "max_tokens": 500
    }
)

data = response.json()
print(data["text"])

# Get crypto prices
prices = requests.get(
    f"{BASE_URL}/api/blockchain/price",
    headers=headers,
    params={"coins": "bitcoin,ethereum", "currency": "usd"}
).json()

print(f"BTC: ${prices['prices']['bitcoin']['usd']:,.2f}")

import requests, time

def chat(message, retries=3):
    for attempt in range(retries):
        r = requests.post(
            "https://opensource-ai-agent.uk/llm/chat",
            headers={"Authorization": f"Bearer {API_KEY}"},
            json={"messages": [{"role": "user", "content": message}]}
        )
        if r.status_code == 429:
            wait = int(r.json().get("retry_after", 60))
            time.sleep(wait)
            continue
        r.raise_for_status()
        return r.json()["text"]

const API_KEY = 'oai_your_key_here';
const BASE_URL = 'https://opensource-ai-agent.uk';

// Chat with AI
async function chat(message) {
  const res = await fetch(`${BASE_URL}/llm/chat`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      messages: [{ role: 'user', content: message }],
      provider: 'groq',
      max_tokens: 500
    })
  });
  if (!res.ok) {
    const err = await res.json();
    throw new Error(err.error);
  }
  const data = await res.json();
  return data.text;
}

// Get crypto prices
async function getCryptoPrices(coins = ['bitcoin', 'ethereum']) {
  const params = new URLSearchParams({ coins: coins.join(','), currency: 'usd' });
  const res = await fetch(`${BASE_URL}/api/blockchain/price?${params}`, {
    headers: { 'Authorization': `Bearer ${API_KEY}` }
  });
  return (await res.json()).prices;
}

// Usage
chat('Explain quantum computing in one paragraph')
  .then(text => console.log(text))
  .catch(err => console.error('Error:', err.message));

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

const (
    apiKey  = "oai_your_key_here"
    baseURL = "https://opensource-ai-agent.uk"
)

func chat(message string) (string, error) {
    body, _ := json.Marshal(map[string]interface{}{
        "messages": []map[string]string{{"role": "user", "content": message}},
        "provider": "groq",
    })
    req, _ := http.NewRequest("POST", baseURL+"/llm/chat", bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil { return "", err }
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result["text"].(string), nil
}

func main() {
    text, err := chat("Hello from Go!")
    if err != nil { fmt.Println("Error:", err); return }
    fmt.Println(text)
}