agno-cookbook

Interact with AgentOS Agent API endpoints. For standard operations (listing agents, running agents, streaming), use the provided CLI script first. Only write custom Python when the script cannot handle the use case (e.g., structured output, dependencies, cancellation, chaining multiple calls). Trigger when: running agents remotely, listing agents, creating agent tests, or asking things like "kick off a run in my test agent" or "what agents do I have configured?"

Interact with AgentOS Team API endpoints. For standard operations (listing teams, running teams, streaming), use the provided CLI script first. Only write custom Python when the script cannot handle the use case (e.g., cancellation, chaining multiple calls, custom error handling). Trigger when: running teams remotely, listing teams, creating team tests, or asking things like "what teams do I have configured?" or "run a task on my research team."

Interact with AgentOS Workflow API endpoints. For standard operations (listing workflows, running workflows, streaming), use the provided CLI script first. Only write custom Python when the script cannot handle the use case (e.g., custom event handling, chaining multiple workflow calls, error handling with retries). Trigger when: running workflows remotely, listing workflows, creating workflow tests, or asking things like "what workflows do I have?" or "run my content pipeline workflow."

Interact with AgentOS Traces API endpoints using the AgentOSClient SDK. For standard operations (listing traces, getting trace details, viewing stats), use the provided CLI script first. Only write custom Python when the script cannot handle the use case (e.g., debugging workflows that chain agent runs with trace inspection, custom filtering, or integration tests). Trigger when: importing AgentOSClient to work with traces, writing scripts to debug agent runs, creating trace tests, or asking things like "show me the traces from my last agent run" or "how many tokens did my agent use?"

Interact with AgentOS Evals API endpoints. For standard operations (listing evals, running accuracy/performance evals, getting eval details), use the provided CLI script first. Only write custom Python when the script cannot handle the use case (e.g., advanced filtering, update/delete operations, chaining evals, agent-as-judge). Trigger when: running evaluations, listing eval runs, benchmarking agents, or asking things like "run an accuracy eval on my agent" or "show me the latest eval results."

Interact with AgentOS Knowledge API endpoints. For standard operations (listing content, uploading files, searching, deleting), use the provided CLI script first. Only write custom Python when the script cannot handle the use case (e.g., pagination, updating metadata, bulk workflows, get config). Trigger when: uploading documents, searching the knowledge base, listing content, or asking things like "upload this md file to my knowledge base" or "search my docs for X."

Interact with AgentOS Memory API endpoints. For standard operations (listing, creating, updating, deleting memories, searching, topics), use the provided CLI script first. Only write custom Python when the script cannot handle the use case (e.g., advanced filtering, stats, chaining multiple calls, integration tests). Trigger when: managing user memories, writing scripts to manage user preferences, creating memory tests, or asking things like "what memories does this user have?" or "add a preference for dark mode."

Interact with AgentOS Session API endpoints. For standard operations (listing, creating, renaming, deleting sessions, viewing runs), use the provided CLI script first. Only write custom Python when the script cannot handle the use case (e.g., persistent conversations, clearing history, bulk deletion, advanced filtering). Trigger when: managing sessions remotely, inspecting session history, creating session tests, or asking things like "find me all sessions from the researcher agent" or "get the latest runs from session X."

Build single Agno agents with tools, structured output, storage, memory, knowledge bases, guardrails, and human-in-the-loop confirmation. Trigger this skill when: importing agno.agent, creating an Agent instance, adding tools to an agent, configuring agent storage/memory, or asking "how do I build an agent with Agno?"

Deploy Agno agents as production APIs using AgentOS. Covers FastAPI integration, database configuration, knowledge registration, and serving. Trigger this skill when: importing agno.os, creating AgentOS instances, deploying agents to production, serving agents via API, or asking "how do I deploy an Agno agent?"

Add input and output guardrails to Agno agents. Covers built-in guardrails (PII detection, prompt injection), custom guardrails, output validation, and moderation. Trigger this skill when: importing agno.guardrails, creating guardrail classes, adding pre_hooks or post_hooks, or asking "how do I add safety checks to my agent?"

Integrate Agno agents with observability platforms, A2A protocol, and external services. Covers OpenTelemetry, Langfuse, Arize Phoenix, Agent-to-Agent protocol, and Discord bots. Trigger this skill when: adding observability to agents, setting up tracing, integrating with Langfuse or similar platforms, or asking "how do I monitor my agents?"

Build knowledge bases for Agno agents using vector databases, embedders, and document readers. Covers ChromaDB, PgVector, LanceDB, document loading, chunking strategies, and hybrid search. Trigger this skill when: importing agno.knowledge, creating Knowledge instances, adding documents to agents, configuring vector databases, or asking "how do I add a knowledge base?"

Add persistent memory to Agno agents. Covers MemoryManager, agentic memory, shared memory between agents, multi-user sessions, and memory tools. Trigger this skill when: importing agno.memory, configuring MemoryManager, enabling agentic memory, or asking "how do I add memory to an agent?"

Configure model providers for Agno agents. Covers Anthropic, OpenAI, Google, Groq, Ollama, AWS Bedrock, Azure, and 40+ other providers. Trigger this skill when: switching model providers, configuring model parameters, using model strings, or asking "how do I use a different model with Agno?"

Build multimodal Agno agents that handle images, audio, and video. Covers image analysis, audio input/output, video captions, and file processing. Trigger this skill when: processing images with agents, handling audio or video, using vision capabilities, or asking "how do I build a multimodal agent?"

Add reasoning and chain-of-thought capabilities to Agno agents. Covers ReasoningTools, built-in model reasoning, reasoning content streaming, and structured problem solving. Trigger this skill when: importing agno.tools.reasoning, enabling chain-of-thought, building agents that think step-by-step, or asking "how do I add reasoning to my agent?"

Configure persistent storage backends for Agno agents and teams. Covers SQLite, PostgreSQL, Redis, MongoDB, and other backends for conversation history, session persistence, and state management. Trigger this skill when: importing agno.db, configuring agent storage, adding session persistence, or asking "how do I persist agent conversations?"

Build multi-agent teams with Agno. Covers coordinate, route, and broadcast modes for agent collaboration. Trigger this skill when: importing agno.team, creating a Team instance, building multi-agent systems, coordinating multiple agents, or asking "how do I build a team with Agno?"

Test Agno agents using the AgentOSClient SDK. Covers connecting to AgentOS, running agents/teams/workflows, streaming, session management, memory operations, and knowledge search. Trigger this skill when: importing agno.client, using AgentOSClient, testing agents remotely, writing agent tests, or asking "how do I test an Agno agent?"

Create custom tools for Agno agents. Covers function tools, the @tool decorator, toolkit classes, RunContext for state access, and MCP tool integration. Trigger this skill when: writing custom agent tools, importing agno.tools, using @tool decorator, creating toolkit classes, or asking "how do I create tools for Agno agents?"

Build step-based workflows with Agno for sequential agent pipelines. Trigger this skill when: importing agno.workflow, creating Workflow or Step instances, building pipelines, chaining agents, or asking "how do I build a workflow with Agno?"

Code review assistance with linting, style checking, and best practices

Git workflow guidance for commits, branches, and pull requests

Get system information using executable scripts