pip install ai-teammate

from ai_teammate import AITeammate

client = AITeammate(api_key="at_your_key_here")

# Create an agent
agent = client.agents.create(
    name="My First Agent",
    system_prompt="You are a helpful assistant that speaks Korean.",
)
print(f"Agent created: {agent.id}")

# Chat with the agent
response = client.chat("Hello!", agent_id=agent.id)
print(response.content)

# List all agents
agents = client.agents.list()
for agent in agents:
    print(f"{agent.name} ({agent.id})")

# Create an agent
agent = client.agents.create(
    name="My Assistant",
    system_prompt="You are a helpful assistant.",
)

# Update an agent
agent = client.agents.update(
    agent_id="abc123",
    name="Updated Name",
    system_prompt="New prompt",
)

# Delete an agent
client.agents.delete("abc123")

# Upload a document (pdf, txt, md, docx, csv)
doc = client.agents.upload_document("abc123", "./menu.txt")
print(f"Uploaded: {doc.filename} ({doc.chunk_count} chunks)")

# List documents
docs = client.agents.list_documents("abc123")
for d in docs:
    print(f"{d.filename} ({d.chunk_count} chunks)")

# Delete a document
client.agents.delete_document("abc123", doc.id)

context = []
response = client.chat("My name is Alice", agent_id="abc123")
context.append({"role": "user", "content": "My name is Alice"})
context.append({"role": "assistant", "content": response.content})

response = client.chat("What's my name?", agent_id="abc123", context=context)
print(response.content)  # "Alice"

# Create a share link
share = client.shares.create(
    agent_id="abc123",
    require_sign_in=True,       # Require end-user authentication
    allow_file_upload=True,     # Allow visitors to upload documents
    include_memory=False,       # Share agent memory with visitors
    max_messages=100,           # Message limit (0 = unlimited)
    expires_in_days=30,         # Link expiration (None = permanent)
)
print(f"Share URL: https://ai-teammate.net{share.share_url}")

# Chat via share link
response = client.shares.chat(share.share_code, "Hello!")
print(response.content)

# Upload a document (triggers RAG indexing)
doc = client.shares.upload_document(share.share_code, "./report.pdf")
print(f"Uploaded: {doc.filename} ({doc.chunk_count} chunks)")

# Chat about the document
response = client.shares.chat(share.share_code, "Summarize the report")
print(response.content)

# List / delete share links
shares = client.shares.list("abc123")
client.shares.delete("abc123", share.id)

from ai_teammate import AITeammate

client = AITeammate(api_key="at_your_api_key")

# 1. Create an agent
agent = client.agents.create(
    name="Customer Support Bot",
    system_prompt="You are a friendly customer support agent.",
)

# 2. Create a share link
share = client.shares.create(
    agent_id=agent.id,
    allow_file_upload=True,
    require_sign_in=False,
    max_messages=100,
)
print(f"Share URL: https://ai-teammate.net{share.share_url}")

# 3. Upload FAQ document
doc = client.shares.upload_document(share.share_code, "./faq.pdf")
print(f"Indexed: {doc.chunk_count} chunks")

# 4. Chat — agent answers using the uploaded document
response = client.shares.chat(share.share_code, "What is the refund policy?")
print(response.content)

# Get Google OAuth URL
result = client.end_users.google_auth_url(
    agent_id="abc123",
    source="my-app",
    return_url="https://myapp.com/callback",
)
print(result["url"])  # Redirect user to this URL

# Exchange code for token (in your callback handler)
auth = client.end_users.google_callback(
    agent_id="abc123",
    code="google_auth_code",
)
token = auth.token
print(f"New user: {auth.is_new}")

# Create a team
team = client.teams.create(
    name="Dream Team",
    chat_mode="brainstorm",
)

# Add agents to team
client.teams.add_agent(team.id, "agent_1")
client.teams.add_agent(team.id, "agent_2")

# Team chat (multi-agent discussion)
response = client.teams.chat(team.id, "Brainstorm startup ideas!")
print(response.summary)

for r in response.responses:
    print(f"[{r.agent_name}] {r.content}")

# Add memory to agent
memory = client.memories.create(
    agent_id="abc123",
    content="User prefers concise responses",
    category="preferences",
)

# List memories
memories = client.memories.list(agent_id="abc123")

# Search memories
results = client.memories.search(agent_id="abc123", query="preferences")

import asyncio

async def main():
    async with AITeammate(api_key="at_xxx") as client:
        # Async chat
        response = await client.achat("Hello!", agent_id="abc123")

        # Async streaming
        async for chunk in client.achat_stream("Tell me a story", agent_id="abc123"):
            print(chunk.content, end="")

asyncio.run(main())

from ai_teammate import (
    AITeammateError,
    AuthenticationError,
    RateLimitError,
    NotFoundError,
)

try:
    response = client.chat("Hello!", agent_id="invalid_id")
except NotFoundError as e:
    print(f"Agent not found: {e}")
except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after} seconds")
except AuthenticationError as e:
    print(f"Invalid API key: {e}")
except AITeammateError as e:
    print(f"Error: {e}")

client = AITeammate(
    api_key="at_xxx",
    base_url="https://ai-teammate.net/api",  # Custom API URL
    timeout=30.0,  # Request timeout in seconds
)

from flask import Flask, request
from ai_teammate import AITeammate

app = Flask(__name__)
client = AITeammate(api_key="at_xxx")

@app.route("/chat", methods=["POST"])
def chat():
    data = request.json
    response = client.chat(data["message"], agent_id=data["agent_id"])
    return {"reply": response.content}

// API Key method
const headers = { "Authorization": "Bearer at_your_api_key" };

// Or JWT token (obtained after login)
const headers = { "Authorization": "Bearer eyJhbG..." };

const res = await fetch("https://ai-teammate.net/api/agents", { headers });
const agents = await res.json();

const res = await fetch("https://ai-teammate.net/api/agents", {
  headers: { "Authorization": "Bearer at_xxx" },
});
const agents = await res.json();

// Each agent object:
// {
//   id: "abc-123",
//   name: "My Agent",
//   avatar_url: "https://api.dicebear.com/7.x/...",
//   enabled_skills: ["core", "ext_device_gw", "ext_session_mgr"],
//   description: "...",
//   ...
// }

const res = await fetch("https://ai-teammate.net/api/agents/abc-123/chat", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer at_xxx",
  },
  body: JSON.stringify({ message: "Hello!" }),
});
const data = await res.json();
console.log(data.content);

// Stateful SSE parser (handles partial chunks)
function createSSEParser() {
  let buffer = "";
  return {
    feed(chunk) {
      buffer += chunk;
      const events = [];
      const parts = buffer.split("\n\n");
      buffer = parts.pop() || "";
      for (const part of parts) {
        for (const line of part.split("\n")) {
          const trimmed = line.startsWith("data: ") ? line.slice(6) : line;
          if (!trimmed) continue;
          try {
            const parsed = JSON.parse(trimmed);
            if (parsed?.type) events.push(parsed);
          } catch {}
        }
      }
      return events;
    },
  };
}

// Usage
const res = await fetch("/api/agents/abc-123/chat/stream", {
  method: "POST",
  headers: { "Content-Type": "application/json", Authorization: "Bearer at_xxx" },
  body: JSON.stringify({ message: "Hello!" }),
});

const reader = res.body.getReader();
const decoder = new TextDecoder();
const parser = createSSEParser();
let content = "";

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  for (const evt of parser.feed(decoder.decode(value, { stream: true }))) {
    if (evt.type === "text") content += evt.content;
    else if (evt.type === "tool_start") console.log("Tool:", evt.name);
    else if (evt.type === "meta") console.log("ConvID:", evt.conversation_id);
  }
}
console.log("Final:", content);

// 1. Get Google auth URL with return_to
const res = await fetch(
  "https://ai-teammate.net/api/auth/google?return_to=" +
  encodeURIComponent("https://myapp.com/auth/callback")
);
const { url } = await res.json();

// 2. Redirect user to Google
window.location.href = url;

// 3. In your /auth/callback page, extract the token
const params = new URLSearchParams(window.location.search);
const token = params.get("token");

// 4. Validate token and get user info
const me = await fetch("https://ai-teammate.net/api/auth/me", {
  headers: { Authorization: "Bearer " + token },
}).then(r => r.json());

console.log(me.name, me.email, me.avatar_url);

// Query by domain
const res = await fetch(
  "https://ai-teammate.net/api/apps/branding?domain=fleet.mycompany.com"
);
const brand = await res.json();
// {
//   name: "My Fleet Control",
//   subtitle: "Smart Factory Ops",
//   logo: "https://mycompany.com/logo.png",
//   accent: "#1428A0",
//   bg: "#0d1117",
//   agent_id: "abc-123"   // null if no match
// }

// Apply to your app
document.title = brand.name;
document.documentElement.style.setProperty("--accent", brand.accent);