Agent Kernel

https://kernel.yaala.ai/docs
Admin
Agent Kernel is an open-source runtime for building, testing, and deploying scalable and compliant...
Tokens:248,872
Snippets:2,357
Trust Score:2.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Common Setup Pattern

Source: https://kernel.yaala.ai/docs/examples/overview

Common setup pattern for all examples: install dependencies with ./build.sh, optionally use ./build.sh local for local development, then run the example with python demo.py or server.py for API examples.

```bash
# Install dependencies  

./build.sh  

  

# For local development  

./build.sh local  

  

# Run the example  

python demo.py  # or server.py for API examples  

```

--------------------------------

### Running the example

Source: https://kernel.yaala.ai/docs/examples/multi-agent

Install the required package, set the OpenAI API key, and run the script.

```bash
pip install agentkernel[crewai]  

export OPENAI_API_KEY=sk-...  

python multi_agent.py  
```

--------------------------------

### Run API Hooks Example

Source: https://kernel.yaala.ai/docs/integrations/hooks

Commands to build the environment, start the API server, and execute tests or direct examples for the API hooks demonstration.

```bash
cd examples/api/hooks  
  
# Build environment  
./build.sh  
  
# Run the API server  
source .venv/bin/activate  
python app.py  
  
# Run tests (in another terminal)  
source .venv/bin/activate  
pytest app_test.py -v  
  
# Or run direct example  
python example_usage.py  
```

--------------------------------

### Basic Slack Integration and Server Setup

Source: https://kernel.yaala.ai/docs/integrations/slack

Example of initializing an OpenAI agent and running a REST API server with the Slack handler. Requires an agent name and instructions to be defined before starting the server.

```python
from agents import Agent as OpenAIAgent  

from agentkernel.api import RESTAPI  

from agentkernel.openai import OpenAIModule  

from agentkernel.slack import AgentSlackRequestHandler  

  

# Create your agent  

general_agent = OpenAIAgent(  

    name="general",  

    handoff_description="Agent for general questions",  

    instructions="You provide assistance with general queries. Give short and clear answers",  

)  

  

# Initialize the OpenAI module with your agent  

OpenAIModule([general_agent])  

  

# Create and run the server with Slack handler  

if __name__ == "__main__":  

    handler = AgentSlackRequestHandler()  

    RESTAPI.run(handler=handler)  
```

--------------------------------

### AgentKernel CLI Example Session

Source: https://kernel.yaala.ai/docs/testing/cli-testing

A transcript showing how to start the agent, list available modules, switch between agents using !select, and manage sessions with !new and !quit.

```text
$ python my_agent.py  

  

AgentKernel CLI (type !help for commands or !quit to exit):  

Available agents:  

  research  

  write  

  review  

  

(research) >> !help  

Available commands:  

!h, !help - Show this help message  

!ld, !load <module_name> - Load agent module  

!ls, !list - List available agents  

!n, !new - Start a new session  

!c, !clear - Clear the current session memory  

!s, !select <agent_name> - Select an agent to run the prompt  

!q, !quit - Exit the program  

  

(research) >> !ls  

Available agents:  

  research  

  write  

  review  

  

(research) >> Find information about Python  

Here's what I found about Python...  

  

(research) >> !select write  

(write) >> I'll help you create a summary...  

  

(write) >> Great, can you review it?  

I'll help you create a summary of the Python information...  

  

(write) >> !select review  

(review) >> Here's my review of the content...  

  

(review) >> !new  

(review) >> This is a new session now  

How can I help you in this new session?  

  

(review) >> !quit
```

--------------------------------

### Quick Start: Install Helm chart and test deployment

Source: https://kernel.yaala.ai/docs/deployment/onprem-kubernetes

Build dependencies, install the chart with dev values and custom image settings, then port-forward and send a test request. The dev flavor runs single replicas with in-cluster NATS and Valkey.

```bash
helm dependency build ak-deployment/ak-k8s/chart  

helm install ak ak-deployment/ak-k8s/chart -f ak-deployment/ak-k8s/chart/values-dev.yaml \  
  --set ioHandler.image.repository=<io image> \  
  --set agentRunner.image.repository=<runner image> --set image.tag=<tag>  
  
  
kubectl port-forward service/ak-agent-kernel-io 8000:80  

curl -s -X POST http://localhost:8000/api/v1/chat \  
  -H 'Content-Type: application/json' \  
  -d '{"prompt": "Hello", "session_id": "s1", "agent": "triage"}'  
```

--------------------------------

### Setup Virtual Environment with Conda

Source: https://kernel.yaala.ai/docs/installation

Create and activate a conda environment, then install Agent Kernel.

```bash
# Create conda environment  

conda create -n .venv python=3.12  

  

# Activate  

conda activate .venv  

  

# Install Agent Kernel  

pip install agentkernel[openai,api]
```

--------------------------------

### Setup Virtual Environment with venv

Source: https://kernel.yaala.ai/docs/installation

Create and activate a virtual environment using venv, then install Agent Kernel.

```bash
# Create virtual environment  

python -m venv .venv  

  

# Activate (Linux/macOS)  

source .venv/bin/activate  

  

# Activate (Windows)  

.venv\Scripts\activate  

  

# Install Agent Kernel  

pip install agentkernel[openai,api]
```

--------------------------------

### Install all features

Source: https://kernel.yaala.ai/docs/installation

Installs all available frameworks, cloud providers, and optional features.

```bash
pip install agentkernel[openai,crewai,langgraph,adk,smolagents,pydanticai,api,aws,azure,gcp,cli]
```

--------------------------------

### Basic Gmail Agent Setup

Source: https://kernel.yaala.ai/docs/integrations/gmail

Initializes an OpenAI agent and starts the Gmail request handler to poll for new emails.

```python
from agents import Agent as OpenAIAgent  

from agentkernel.openai import OpenAIModule  

from agentkernel.gmail import AgentGmailRequestHandler  

import asyncio  

  
general_agent = OpenAIAgent(  

    name="general",  

    instructions="""You are an AI email assistant.  

1. Extract sender's name from the "From:" field  

2. Start response with "Hi [Name],"  

3. Address their questions professionally  

4. Keep it brief (2-3 paragraphs max)  

5. Do NOT include "Subject:" or signatures  

"""  

)  

  
OpenAIModule([general_agent])  

  
if __name__ == "__main__":  

    handler = AgentGmailRequestHandler()  

    handler.authenticate()  

    asyncio.run(handler.start_polling())
```

--------------------------------

### Basic Instagram Bot Setup with AgentKernel

Source: https://kernel.yaala.ai/docs/integrations/instagram

Complete setup for an Instagram bot using AgentKernel. Creates an OpenAI agent with Instagram-specific instructions, initializes the OpenAIModule, and starts the REST API with the Instagram request handler.

```python
from agents import Agent as OpenAIAgent  

from agentkernel.api import RESTAPI  

from agentkernel.openai import OpenAIModule  

from agentkernel.instagram import AgentInstagramRequestHandler  

  

# Create your AI agent  

instagram_agent = OpenAIAgent(  
    name="general",  
    handoff_description="Helpful Instagram assistant",  
    instructions="""You are a friendly assistant on Instagram DMs.  
    - Keep responses concise and mobile-friendly  
    - Use emojis sparingly to maintain professionalism  
    - Break long explanations into short paragraphs  
    - Be conversational and helpful  
    - Remember: Instagram DMs have a 1000 character limit per message"""  
)  

  

# Initialize the module with your agent  

OpenAIModule([instagram_agent])  

  

# Start the server with Instagram integration  

if __name__ == "__main__":  
    handler = AgentInstagramRequestHandler()  
    RESTAPI.run([handler])  

```

--------------------------------

### Basic Messenger Bot Setup

Source: https://kernel.yaala.ai/docs/integrations/messenger

Initializes an AI agent with specific instructions and starts the Messenger request handler using the RESTAPI.

```python
from agents import Agent as OpenAIAgent  

from agentkernel.api import RESTAPI  

from agentkernel.openai import OpenAIModule  

from agentkernel.messenger import AgentMessengerRequestHandler  

  

# Create your AI agent  

customer_service_agent = OpenAIAgent(  

    name="customer_service",  

    handoff_description="Helpful customer service agent",  

    instructions="""You are a friendly customer service assistant on Facebook Messenger.  

    - Keep responses concise and mobile-friendly  

    - Use emojis sparingly to maintain professionalism  

    - Break long explanations into short paragraphs  

    - Be conversational and helpful"""  

)  

  

# Initialize the module with your agent  

OpenAIModule([customer_service_agent])  

  

# Start the server with Messenger integration  

if __name__ == "__main__":  

    handler = AgentMessengerRequestHandler()  

    RESTAPI.run([handler])  
```

--------------------------------

### Install agentkernel[pydanticai]

Source: https://kernel.yaala.ai/docs/frameworks/pydantic-ai

Installs the provider-agnostic pydantic-ai-slim core, which ships no model provider. Use this as the first step before installing a specific provider.

```bash
pip install agentkernel[pydanticai]  
```

--------------------------------

### Install Framework Extras

Source: https://kernel.yaala.ai/docs/quick-start

Command to install framework-specific dependencies using pip.

```bash
pip install agentkernel[your-framework]  
```

--------------------------------

### Install multiple frameworks

Source: https://kernel.yaala.ai/docs/installation

Installs support for multiple AI frameworks simultaneously.

```bash
pip install agentkernel[openai,crewai,langgraph]
```

--------------------------------

### Example Test Session

Source: https://kernel.yaala.ai/docs/testing/cli-testing

Demonstrates a complete test session using the Test class, including starting the session, sending inputs, setting expectations, and ensuring cleanup with a try-finally block.

```python
import asyncio  

from agentkernel.test import Test  

  

async def test_cricket_knowledge():  

    test = Test("demo.py", match_threshold=0.6)  

      

    try:  

        await test.start()  

          

        # Test basic question - expected is a list  

        await test.send("Who won the 1996 cricket world cup?")  

        await test.expect(["Sri Lanka won the 1996 cricket world cup."])  

          

        # Test follow-up question with multiple acceptable answers  

        await test.send("Which country hosted the tournament?")  

        await test.expect([  

            "Co-hosted by India, Pakistan and Sri Lanka.",  

            "India, Pakistan and Sri Lanka co-hosted the tournament."  

        ])  

          

        print("All tests passed!")  

          

    finally:  

        await test.stop()  

  

if __name__ == "__main__":  

    asyncio.run(test_cricket_knowledge())
```

--------------------------------

### Install for Development

Source: https://kernel.yaala.ai/docs/installation

Clone the repository and install in development mode to contribute or modify source code.

```bash
# Clone the repository  

git clone https://github.com/yaalalabs/agent-kernel.git  

cd agent-kernel/ak-py  

  

# Install in development mode  

./build.sh  

  

# Go to any example and run  

./build.sh local
```

--------------------------------

### Install multi-cloud deployment support

Source: https://kernel.yaala.ai/docs/installation

Installs dependencies for deploying to multiple cloud providers.

```bash
pip install agentkernel[aws,azure,gcp]
```

--------------------------------

### Start MCP Server

Source: https://kernel.yaala.ai/docs/api/mcp-server

Initialize and run the REST API server to start the MCP server.

```python
from agentkernel.api import RESTAPI

if __name__ == "__main__":
    RESTAPI.run()
```

--------------------------------

### Install optional features

Source: https://kernel.yaala.ai/docs/installation

Installs various optional features such as multimodal support, tracing, and authentication helpers.

```bash
pip install agentkernel[multimodal]  # Image/file attachment support

pip install agentkernel[thread]      # Conversation threads (LLM auto-naming)

pip install agentkernel[mcp]         # MCP server

pip install agentkernel[a2a]         # Agent-to-Agent server

pip install agentkernel[langfuse]    # Langfuse tracing

pip install agentkernel[openllmetry] # OpenLLMetry tracing

pip install agentkernel[auth]        # JWT auth helpers
```

--------------------------------

### Run Session Context Example

Source: https://kernel.yaala.ai/docs/integrations/hooks

Commands to build the environment, run the session context demo, and execute tests.

```bash
cd examples/cli/session-context  
  
# Build environment  
./build.sh  
  
# Run the demo  
python demo.py  
  
# Run tests (in another terminal)  
uv run pytest -s  
```

--------------------------------

### Deploy Infrastructure with Terraform

Source: https://kernel.yaala.ai/docs/deployment/gcp-containerized

Builds the example package and deploys infrastructure using Terraform: initialize, plan, and apply.

```bash
# 1. Build example package  
./build.sh  

# 2. Deploy infrastructure  
cd deploy  
terraform init  
terraform plan  
terraform apply  

```

--------------------------------

### Install session and state stores

Source: https://kernel.yaala.ai/docs/installation

Installs dependencies for Redis or Valkey session, response, and attachment stores.

```bash
pip install agentkernel[redis]    # Redis session/response/attachment stores

pip install agentkernel[valkey]   # Valkey session/response stores (Redis fork)
```

--------------------------------

### Startup logs for in_memory transport

Source: https://kernel.yaala.ai/docs/advanced/queue-mode-guide

Example log output indicating that the in_memory queue transport has successfully resolved and the single-process pipeline is starting.

```text
ak.api.http - INFO - in_memory queue transport resolved: starting the single-process pipeline topology  

ak.pipeline.io_handler - INFO - IOHandler starting: mode=rest_sync, transport=in_memory, topology=single-process
```

--------------------------------

### KnowledgeBuilder setup with semantic_map

Source: https://kernel.yaala.ai/docs/advanced/knowledge-bases

Demonstrates registering backends, defining a semantic map for runtime token replacement, and building KB tools.

```python
# 1) Import the pieces  

from agentkernel.knowledgebase.knowledgebuilder import KnowledgeBuilder  

from agentkernel.knowledgebase.chroma import ChromaManager  

from agentkernel.knowledgebase.neo4j import Neo4jManager  

  

# 2) Define (lightweight) backends and their schemas  

#    In real code you would supply full schema dictionaries as in the demos.  

v_db = ChromaManager(name="ChromaDB").add_schema({"description": "Vector store"})  

g_db = Neo4jManager(name="Neo4jDB").add_schema({"description": "Graph DB"})  

  

# 3) Define the semantic_map - agent prompts use the LEFT side tokens  

#    and the runtime replaces them with the RIGHT side physical targets.  

semantic_map = {  

  "<SHEETS_SOURCE>": "TABLE(kb_sheets.system.sheet(id => 'SHEET_ID'))",  # Trino/Starburst wrapper  

  "<MONGO_SOURCE>": "catalog.schema.clients",  # Example catalog.schema.table path  

}  

  

# 4) Create the KnowledgeBuilder with backends + semantic_map  

kb = KnowledgeBuilder([v_db, g_db], semantic_map=semantic_map)  

  

# 5) Build the KB tools (framework adapters bind these into agents)  

#    The exact return shape can be a list of callables; here we store as a variable.  

kb_tools = kb.build()  

  

# 6) Agent constructs a query using the logical placeholder token  

query = "SELECT client_name, status FROM <MONGO_SOURCE> WHERE status = 'active' LIMIT 5"  

  

# 7) At runtime, before the backend executes the SQL, KnowledgeBuilder  

#    replaces `<MONGO_SOURCE>` with `catalog.schema.clients` from `semantic_map`.  

#    Then `read_kb()` sends the resolved SQL to the correct Starburst backend.  

#    (In practice the agent calls the `read_kb` callable from `kb_tools`.)  

resolved_query = query.replace("<MONGO_SOURCE>", semantic_map["<MONGO_SOURCE>"])  

# read_results = read_kb("StarburstDB-mongo", resolved_query)  

  

# NOTE: Keep placeholders consistent in prompts and document required  

#       query templates in each backend's `schema()` to avoid runtime errors.
```

--------------------------------

### Install dependencies and run the agent

Source: https://kernel.yaala.ai/docs/examples/basic-agent

Commands to install the required package, set the OpenAI API key, and execute the agent script.

```bash
# Install dependencies  

pip install agentkernel[crewai]  

  

# Set API key  

export OPENAI_API_KEY=sk-...  

  

# Run the agent  

python basic_agent.py  
```

--------------------------------

### Using runners via Runtime

Source: https://kernel.yaala.ai/docs/core-concepts/runner

Runners are typically accessed through agents and invoked via the Runtime, which applies hooks and persistence. This example shows how to get the current Runtime, retrieve an agent and a session, and run the agent with a prompt using runtime.run().

```python
from agentkernel.core import Runtime  

from agentkernel.core.model import AgentRequestText  

  

runtime = Runtime.current()  

agent = runtime.agents().get("assistant")  

session = runtime.sessions().get("user-123") or runtime.sessions().new("user-123")  

  

# Preferred: run through the Runtime so hooks and persistence apply  

reply = await runtime.run(agent, session, [AgentRequestText(prompt="Hello")])  

```

--------------------------------

### Initialize KnowledgeBuilder with Chroma and Neo4j

Source: https://kernel.yaala.ai/docs/advanced/knowledge-bases

Demonstrates how to instantiate backend managers, add schemas, and build the toolset using KnowledgeBuilder.

```python
from agentkernel.knowledgebase.knowledgebuilder import KnowledgeBuilder  

from agentkernel.knowledgebase.chroma import ChromaManager  

from agentkernel.knowledgebase.neo4j import Neo4jManager  

  
v_db = ChromaManager(name="ChromaDB").add_schema({...})  

g_db = Neo4jManager(name="Neo4jDB").add_schema({...})  

  
kb_tools = KnowledgeBuilder([v_db, g_db]).build()  
```

--------------------------------

### Example Agent Kernel CLI session output

Source: https://kernel.yaala.ai/docs/quick-start

Shows an interactive session: the CLI defaults to the first agent (triage), starts a new session, lists available agents, selects 'math', and responds to a math query. The output includes the session ID and the agent's response.

```text
(kernel) >> Using in-memory session store  
AgentKernel CLI (type !help for commands or !quit to exit):  
(kernel) >> No agent was requested. Defaulting to first agent in the list  
(kernel) >> Selected agent: triage  
(kernel) >> Starting new session: 07ec500e-f103-4b0e-8ecb-d794232f5992  
(triage) >>  
(triage) >> !list  
Available agents:  
  triage  
  math  
  general  

(triage) >> !select math  
(math) >> What is 2 + 2?  

[math agent responds]  
(math) >> 2 + 2 = 4. This is basic addition where we combine two quantities...  

(math) >>  
```

--------------------------------

### Install and manage Agent Skills with ak CLI

Source: https://kernel.yaala.ai/docs/agent-skills

Commands to list, install, update, and manage Agent Kernel skills for various coding assistants. Use `ak skill install --assistant <name>` to target a specific assistant, and `ak skill install <skill-name>` to install a single skill. The default assistant is GitHub Copilot, installing to `.agents/skills/`.

```bash
# List available skills  
ak skill list  

# List supported coding assistants and their skill directories  
ak skill assistants  

# Install all skills (default: GitHub Copilot → .agents/skills/)  
ak skill install  

# Install for a specific coding assistant  
ak skill install --assistant claude    # → .claude/commands/  
ak skill install --assistant cursor    # → .cursor/rules/  
ak skill install --assistant windsurf  # → .windsurf/rules/  
ak skill install --assistant codex     # → .codex/skills/  
ak skill install --assistant aider     # → .aider/skills/  

# Install a single skill  
ak skill install ak-init --assistant claude  

# Update previously installed skills to latest version  
ak skill update  
ak skill update --assistant claude  
```

--------------------------------

### Install Pydantic AI support

Source: https://kernel.yaala.ai/docs/installation

Installs the provider-agnostic pydantic-ai-slim core. You must also install the specific provider you intend to use.

```bash
pip install agentkernel[pydanticai]
```

--------------------------------

### Define and register agents across multiple frameworks

Source: https://kernel.yaala.ai/docs/frameworks/multi-framework

Demonstrates initializing agents using OpenAI, CrewAI, and LangGraph, then registering them with their respective modules.

```python
# OpenAI Agents SDK - Great for production workflows  
customer_service = OpenAIAgent(  
    name="customer_service",  
    instructions="Handle customer inquiries professionally with access to tools.",  
)  
  
# CrewAI - Excellent for role-based collaboration    
research_agent = CrewAIAgent(  
    role="researcher",  
    goal="Conduct thorough research on topics",  
    backstory="Expert researcher with attention to detail",  
)  
  
# LangGraph - Perfect for complex multi-step workflows  
workflow_agent = create_langgraph_workflow()  
  
OpenAIModule([customer_service])  
CrewAIModule([research_agent])   
LangGraphModule([workflow_agent])
```

--------------------------------

### Install CrewAI support

Source: https://kernel.yaala.ai/docs/installation

Installs the extras required for CrewAI.

```bash
pip install agentkernel[crewai]
```

--------------------------------

### Install AWS dependencies

Source: https://kernel.yaala.ai/docs/quick-start

Install the necessary AWS dependencies for agentkernel.

```bash
# Install AWS dependencies  

pip install agentkernel[aws]  
```

--------------------------------

### Multi-Agent Setup

Source: https://kernel.yaala.ai/docs/integrations/telegram

Configure multiple agents with specific instructions and handoff descriptions. Use OpenAIModule to register the agents for use within the application.

```python
support_agent = OpenAIAgent(  

    name="support",  

    handoff_description="Customer support agent",  

    instructions="Provide helpful customer support. Be concise for Telegram.",  

)  

  

sales_agent = OpenAIAgent(  

    name="sales",  

    handoff_description="Sales inquiry agent",  

    instructions="Help with product questions. Keep responses brief.",  

)  

  

OpenAIModule([support_agent, sales_agent])
```

--------------------------------

### Install Guardrails Package

Source: https://kernel.yaala.ai/docs/advanced/guardrails-openai

Command to install the required guardrails package.

```bash
pip install openai-guardrails  
```

--------------------------------

### Configure Storage Backends

Source: https://kernel.yaala.ai/docs/advanced/scheduling

Configuration examples for Redis, Valkey, and DynamoDB storage backends. Note that DynamoDB requires a partition key named task_id.

```yaml
# Redis
schedule:
  store:
    type: redis
    redis:
      url: redis://localhost:6379
      prefix: "ak:schedule:"
      ttl: 0                     # 0 disables expiry (the default)

# Valkey (Redis-protocol compatible; requires the `valkey` extra)
schedule:
  store:
    type: valkey
    valkey:
      url: valkey://localhost:6379

# DynamoDB — table needs partition key `task_id` (S), no sort key
schedule:
  store:
    type: dynamodb
    dynamodb:
      table_name: ak-agent-schedules
```

--------------------------------

### Knowledge Management Workflow Example

Source: https://kernel.yaala.ai/docs/core-concepts/overview

A complete flow demonstrating backend definition, composition with semantic mapping, and tool usage by an agent.

```python
from agentkernel.knowledgebase.chroma import ChromaManager  

from agentkernel.knowledgebase.neo4j import Neo4jManager  

from agentkernel.knowledgebase.knowledgebuilder import KnowledgeBuilder  

  

# 1. Define backends  

vector_store = ChromaManager(name="VectorDB", description="...")  

graph_db = Neo4jManager(name="GraphDB", description="...")  

  

# 2. Compose with semantic mapping  

kb = KnowledgeBuilder(  

    [vector_store, graph_db],  

    semantic_map={"<GRAPH>": "neo4j.default.graph"},  

)  

  

# 3. Agent uses tools  

kb.build()  # Creates get_schemas(), read_kb(), write_kb(), etc.  

  

# 4. Agent can now:  

# - Call get_schemas() to discover backends  

# - Call read_kb("GraphDB", "MATCH (n) LIMIT 5") to query the graph  

# - Call write_kb("VectorDB", text="new fact") to store knowledge  
```

--------------------------------

### Install CLI testing tools

Source: https://kernel.yaala.ai/docs/installation

Installs dependencies for interactive command-line testing.

```bash
pip install agentkernel[cli]
```

--------------------------------

### Install Agent Kernel with Framework Integrations

Source: https://kernel.yaala.ai/docs/advanced/traceability

Install the base package with Logfire and specific framework integrations.

```bash
# OpenAI with Logfire  

pip install agentkernel[openai,logfire]  

  

# CrewAI with Logfire  

pip install agentkernel[crewai,logfire]  

  

# Google ADK with Logfire  

pip install agentkernel[adk,logfire]
```

--------------------------------

### Install Agent Kernel with Logfire

Source: https://kernel.yaala.ai/docs/advanced/traceability

Install the base package with Logfire support.

```bash
pip install agentkernel[logfire]
```

--------------------------------

### Install Agent Kernel with OpenLLMetry

Source: https://kernel.yaala.ai/docs/advanced/traceability

Install the base package with OpenLLMetry support.

```bash
pip install agentkernel[openllmetry]
```

--------------------------------

### Install Agent Kernel with Langfuse

Source: https://kernel.yaala.ai/docs/advanced/traceability

Install the base package with Langfuse support.

```bash
pip install agentkernel[langfuse]
```

--------------------------------

### Install Agent Kernel with Framework Integrations

Source: https://kernel.yaala.ai/docs/advanced/traceability

Install Agent Kernel with specific framework integrations and OpenLLMetry support.

```bash
# OpenAI with OpenLLMetry  

pip install agentkernel[openai,openllmetry]  

  

# LangGraph with OpenLLMetry  

pip install agentkernel[langgraph,openllmetry]  

  

# CrewAI with OpenLLMetry  

pip install agentkernel[crewai,openllmetry]  

  

# Google ADK with OpenLLMetry  

pip install agentkernel[adk,openllmetry]
```

--------------------------------

### GET /a2a/{agent}/v1/card

Source: https://kernel.yaala.ai/docs/api/a2a-server

Gets the agent card for the specified agent.

```APIDOC
## GET /a2a/{agent}/v1/card

### Description
Gets the agent card for the specified agent.

### Method
GET

### Endpoint
/a2a/{agent}/v1/card

### Parameters
#### Path Parameters
- **agent** (string) - Required - The name of the agent.

### Response
#### Success Response (200)
- **name** (string) - Agent name.
- **description** (string) - Agent description.
- **endpoint** (string) - Agent endpoint.

#### Response Example
{
  "name": "agent1",
  "description": "Description of agent1",
  "endpoint": "/a2a/agent1"
}
```

--------------------------------

### Install Agent Skills

Source: https://kernel.yaala.ai/docs/agent-skills

Run this command to install Agent Skills into your project. It is the first step in the workflow.

```bash
ak skill install
```
Tokens:
Raw