Lyzr

https://docs.lyzr.ai/
Admin
Lyzr is an enterprise-ready agent framework for building generative AI applications with...
Tokens:434,477
Snippets:4,119
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies and Configure Environment

Source: https://docs.lyzr.ai/cognis/cookbooks/cognis-agno

Installation commands and environment variable setup for both hosted and open-source versions.

```bash
pip install lyzr-adk agno openai
```

```bash
export LYZR_API_KEY="your-lyzr-api-key"
export OPENAI_API_KEY="your-openai-api-key"
```

```bash
pip install lyzr-cognis agno openai
```

```bash
export GEMINI_API_KEY="your-gemini-key"
export OPENAI_API_KEY="your-openai-api-key"
```

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

### Create Agent - Quick Start

Source: https://docs.lyzr.ai/lyzr-adk/agents/creating-agents

A quick start example demonstrating how to initialize the Lyzr Studio and create a basic AI agent.

```APIDOC
## POST /api/agents

### Description
Create AI agents with the Lyzr ADK. This endpoint allows for the creation of AI agents with customizable LLM providers, roles, and features.

### Method
POST

### Endpoint
/api/agents

### Parameters
#### Request Body
- **name** (str) - Required - Agent name (1-200 characters)
- **provider** (str) - Optional - LLM provider and model. Examples: `"gpt-4o"`, `"claude-sonnet-4.5"`, `"openai/gpt-4o"`
- **role** (str) - Optional - Agent's role or persona (e.g., "Customer support agent")
- **goal** (str) - Optional - Agent's primary objective (e.g., "Help users resolve issues")
- **instructions** (str) - Optional - Detailed instructions for agent behavior
- **description** (str) - Optional - Agent description (max 1000 characters)
- **temperature** (float) - Optional - Creativity/randomness (0.0-2.0). Lower = more focused, higher = more creative. Default: 0.7
- **top_p** (float) - Optional - Nucleus sampling (0.0-1.0). Controls diversity of responses. Default: 0.9
- **response_model** (BaseModel) - Optional - Pydantic model for structured outputs
- **memory** (int) - Optional - Number of messages to remember (1-50)
- **contexts** (List[Context]) - Optional - Background information contexts
- **rai_policy** (RAIPolicy) - Optional - Responsible AI policy for guardrails
- **file_output** (bool) - Optional - Enable file generation (PDF, DOCX, etc.). Default: False
- **image_model** (ImageModelConfig) - Optional - Image generation model configuration
- **reflection** (bool) - Optional - Enable self-reflection to reduce hallucinations. Default: False
- **bias_check** (bool) - Optional - Enable bias detection in responses. Default: False
- **llm_judge** (bool) - Optional - Enable third-party LLM to evaluate responses. Default: False
- **groundedness_facts** (List[str]) - Optional - Facts for response validation
- **llm_credential_id** (str) - Optional - Custom credential ID for LLM (from Studio UI). Default: Auto
- **additional_model_params** (dict) - Optional - Additional provider-specific model parameters

### Request Example
```json
{
  "name": "Support Bot",
  "provider": "gpt-4o",
  "role": "Customer support agent",
  "goal": "Help customers resolve their issues",
  "instructions": "Be empathetic, clear, and solution-oriented"
}
```

### Response
#### Success Response (200)
- **agent** (Agent) - The created agent object

#### Response Example
```json
{
  "agent": {
    "id": "agent-123",
    "name": "Support Bot",
    "role": "Customer support agent",
    "goal": "Help customers resolve their issues"
  }
}
```
```

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

### Get Knowledge Base (example)

Source: https://docs.lyzr.ai/enterprise/adk/studio

An example demonstrating how to get a knowledge base by its ID and print its name.

```python
kb = studio.get_knowledge_base("kb_123")
print(kb.name)
```

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

### Quick Start: Create and Run an Agent

Source: https://docs.lyzr.ai/enterprise/adk/overview

Initialize the Lyzr Studio with your API key, create an agent with specified parameters, and run it to get a response.

```python
from lyzr import Studio

# Initialize the SDK
studio = Studio(api_key="your-api-key")

# Create an agent
agent = studio.create_agent(
    name="My Assistant",
    provider="gpt-4o",
    role="Helpful assistant",
    goal="Help users with their questions",
    instructions="Be concise and accurate"
)

# Run the agent
response = agent.run("What is machine learning?")
print(response.response)
```

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

### Quick Start: Agent and Streaming Response

Source: https://docs.lyzr.ai/enterprise/adk/responses/responses

Demonstrates how to create an agent and run it for both standard and streaming responses. Requires API key setup.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")
agent = studio.create_agent(
    name="Assistant",
    provider="gpt-4o"
)

# AgentResponse
response = agent.run("Hello!")
print(response.response)
print(response.session_id)

# AgentStream (streaming)
for chunk in agent.run("Tell a story", stream=True):
    print(chunk.content, end="")
```

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

### Python SDK Example

Source: https://docs.lyzr.ai/enterprise/learn/cookbooks/voice-agent

A Python script demonstrating how to start and end a voice agent session using the Lyzr Voice API.

```python
import os
import time

import requests

API_KEY = os.environ["LYZR_API_KEY"]
AGENT_ID = os.environ["LYZR_VOICE_AGENT_ID"]
BASE_URL = os.getenv("VOICE_API_BASE_URL", "https://voice-livekit.studio.lyzr.ai/v1")

HEADERS = {
    "x-api-key": API_KEY,
    "accept": "application/json",
    "Content-Type": "application/json",
}


def start_session() -> dict:
    payload = {
        "userIdentity": f"user_{int(time.time())}",
        "agentId": AGENT_ID,
    }

    response = requests.post(
        f"{BASE_URL}/sessions/start", headers=HEADERS, json=payload, timeout=30
    )
    response.raise_for_status()
    data = response.json()

    print(f"Session ID:  {data['sessionId']}")
    print(f"Room name:   {data['roomName']}")
    print(f"LiveKit URL: {data['livekitUrl']}")
    return data


def end_session(room_name: str) -> None:
    response = requests.post(
        f"{BASE_URL}/sessions/end",
        headers=HEADERS,
        json={"roomName": room_name},
        timeout=30,
    )
    response.raise_for_status()
    print("Session ended.")


if __name__ == "__main__":
    session = start_session()
    print("Connect a LiveKit client now. Press Enter when you're done.")
    input()
    end_session(session["roomName"])
```

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

### Detailed Image Prompt Example

Source: https://docs.lyzr.ai/enterprise/adk/file-image-output/image-generation

Use detailed descriptions to guide image generation for better results. This example shows a good vs. less effective prompt for creating an office space image.

```python
# Good: Detailed description
response = agent.run("""
Create an image of a modern office space:
- Large windows with city view
- Minimalist furniture in neutral colors
- Green plants for accents
- Natural lighting
- A few people working at desks
- Style: Photorealistic
""")

# Less effective: Vague description
response = agent.run("Create an office image")
```

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

### Examples of kb.with_config() Usage

Source: https://docs.lyzr.ai/enterprise/adk/knowledge-bases/querying

Illustrates different ways to configure retrieval settings for precise, diverse, or recent content. Includes an example of using a configured KB in `agent.run()`.

```python
# High precision queries
precise_kb = kb.with_config(
    top_k=3,
    score_threshold=0.8,
    retrieval_type="basic"
)

# Diverse results
diverse_kb = kb.with_config(
    top_k=10,
    retrieval_type="mmr"
)

# Recent content priority
recent_kb = kb.with_config(
    retrieval_type="time_aware",
    time_decay_factor=0.7
)

# Use in agent.run()
response = agent.run("Question?", knowledge_bases=[precise_kb])
```

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

### Create Context (example)

Source: https://docs.lyzr.ai/enterprise/adk/studio

An example of creating a context with a specific name and value.

```python
context = studio.create_context(
    name="company_info",
    value="Acme Corp - Founded 2020, serves 50k customers"
)
```

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

### Add PDF Examples

Source: https://docs.lyzr.ai/lyzr-adk/knowledge-bases/adding-documents

Examples showing basic PDF ingestion, custom chunking settings, and metadata inclusion.

```python
# Basic usage
kb.add_pdf("document.pdf")

# With custom chunking
kb.add_pdf(
    "document.pdf",
    chunk_size=2048,
    chunk_overlap=256
)

# With metadata
kb.add_pdf(
    "manual.pdf",
    extra_info='{"version": "2.0", "department": "support"}'
)
```

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

### Add TXT Example

Source: https://docs.lyzr.ai/lyzr-adk/knowledge-bases/adding-documents

Example showing basic ingestion of a plain text file.

```python
kb.add_txt("notes.txt")
```

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

### Install LiveKit Client Packages

Source: https://docs.lyzr.ai/enterprise/learn/cookbooks/voice-agent

Install the necessary LiveKit client packages for your project.

```bash
pnpm add livekit-client @livekit/components-react @livekit/components-styles
```

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

### Quick Start: Manage Knowledge Bases and Documents

Source: https://docs.lyzr.ai/enterprise/adk/knowledge-bases/managing-kb

This snippet demonstrates common operations for managing knowledge bases and their documents, including listing, getting, deleting documents, resetting, and deleting the entire knowledge base. Ensure you have initialized the Studio with your API key.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

# List all knowledge bases
kbs = studio.list_knowledge_bases()
for kb in kbs:
    print(f"{kb.id}: {kb.name}")

# Get a specific knowledge base
kb = studio.get_knowledge_base("kb_id")

# List documents
docs = kb.list_documents()

# Delete specific documents
kb.delete_documents(["doc_id_1", "doc_id_2"])

# Reset (clear all documents)
kb.reset()

# Delete the knowledge base
kb.delete()
```

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

### Q&A Bot Example

Source: https://docs.lyzr.ai/lyzr-adk/knowledge-bases/querying

An example demonstrating how to set up and use an agent for answering frequently asked questions using a knowledge base.

```APIDOC
### Q&A Bot

```python
kb = studio.get_knowledge_base("faq_kb")

agent = studio.create_agent(
    name="FAQ Bot",
    provider="gpt-4o",
    role="FAQ assistant",
    goal="Answer frequently asked questions",
    instructions="Answer based on the FAQ content. If not found, say so."
)

questions = [
    "What are your business hours?",
    "How do I reset my password?",
    "What payment methods do you accept?"
]

for question in questions:
    response = agent.run(question, knowledge_bases=[kb])
    print(f"Q: {question}")
    print(f"A: {response.response}\n")
```
```

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

### Add DOCX Example

Source: https://docs.lyzr.ai/lyzr-adk/knowledge-bases/adding-documents

Example showing how to add a Word document with custom chunk size.

```python
kb.add_docx("report.docx", chunk_size=1500)
```

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

### Example cURL Request

Source: https://docs.lyzr.ai/enterprise/api/tools/credentials/create

An example of how to use cURL to send a POST request to create a tool credential. Includes necessary headers and a sample request body.

```sh
curl -X POST "https://agent-prod.studio.lyzr.ai/v3/tools/credentials" ^
-H "accept: application/json" ^
-H "content-type: application/json" ^
-H "x-api-key: sk-default-EXAMPLEKEY123" ^
-d "{\"name\":\"string\",\"provider_id\":\"string\",\"credentials\":{},\"meta_data\":{}}"
```

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

### Install Lyzr Memory Libraries

Source: https://docs.lyzr.ai/cognis/cookbooks/getting-started

Install the required package and set the necessary API environment variables for your chosen version.

```bash
pip install lyzr-adk
```

```bash
export LYZR_API_KEY="your-lyzr-api-key"
```

```bash
pip install lyzr-cognis
```

```bash
export GEMINI_API_KEY="your-gemini-key"    # For embeddings
export OPENAI_API_KEY="your-openai-key"    # For fact extraction
```

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

### Complete Tool Parameter Example

Source: https://docs.lyzr.ai/enterprise/adk/tools/creating-tools

A comprehensive example demonstrating how to define multiple parameters with various types, including enums and booleans, and specifying required fields.

```python
parameters = {
    "type": "object",
    "properties": {
        "destination": {
            "type": "string",
            "description": "Destination city"
        },
        "departure_date": {
            "type": "string",
            "description": "Departure date (YYYY-MM-DD)"
        },
        "passengers": {
            "type": "integer",
            "description": "Number of passengers"
        },
        "class": {
            "type": "string",
            "enum": ["economy", "business", "first"],
            "description": "Cabin class"
        },
        "direct_only": {
            "type": "boolean",
            "description": "Only show direct flights"
        }
    },
    "required": ["destination", "departure_date"]
}
```

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

### OpenAI Model Examples

Source: https://docs.lyzr.ai/enterprise/adk/providers/providers

Examples of creating agents with different OpenAI models, highlighting their specific capabilities like balanced performance, speed, cost-effectiveness, and reasoning.

```python
# GPT-4o - balanced performance
agent = studio.create_agent(provider="gpt-4o")

# GPT-4o Mini - fast and cost-effective
agent = studio.create_agent(provider="gpt-4o-mini")

# GPT-5 - advanced reasoning
agent = studio.create_agent(provider="gpt-5")

# O3 - reasoning model
agent = studio.create_agent(provider="o3")
```

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

### Install lyzr-adk for Hosted Integration

Source: https://docs.lyzr.ai/cognis/cookbooks/cognis-langchain

Install the lyzr-adk package and necessary LangChain components for the hosted integration. Ensure your API keys are set as environment variables.

```bash
pip install lyzr-adk langchain langchain-openai
```

```bash
export LYZR_API_KEY="your-lyzr-api-key"
export OPENAI_API_KEY="your-openai-api-key"
```

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

### Install Cognis Hosted (lyzr-adk)

Source: https://docs.lyzr.ai/cognis/comparison

Use this command to install the lyzr-adk package for the hosted version of Cognis. This is the quickest way to get started with the Lyzr cloud API.

```bash
pip install lyzr-adk
```

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

### Quick Start: Create and Run an Agent

Source: https://docs.lyzr.ai/enterprise/adk/studio

Initialize the Studio with an API key, create a new agent with specified parameters, and run a task. Ensure you have your API key ready.

```python
from lyzr import Studio

# Initialize with API key
studio = Studio(api_key="your-api-key")

# Create an agent
agent = studio.create_agent(
    name="My Agent",
    provider="gpt-4o",
    role="Assistant",
    goal="Help users",
    instructions="Be helpful"
)

# Run the agent
response = agent.run("Hello!")
print(response.response)
```

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

### Quick Start: Running an Agent

Source: https://docs.lyzr.ai/enterprise/adk/agents/running-agents

Initialize the Studio, create an agent, and run it with a message. The response can then be accessed.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

agent = studio.create_agent(
    name="Assistant",
    provider="gpt-4o",
    role="Helpful assistant",
    goal="Answer questions",
    instructions="Be concise and accurate"
)

# Run the agent
response = agent.run("What is machine learning?")
print(response.response)
```

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

### Quick Start: Create Knowledge Base, Add Documents, and Query with Agent

Source: https://docs.lyzr.ai/enterprise/adk/knowledge-bases/overview

This snippet demonstrates the end-to-end process of creating a knowledge base, adding PDF and website documents, creating an agent, and querying the agent using the knowledge base.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

# Create a knowledge base
kb = studio.create_knowledge_base(
    name="product_docs",
    vector_store="qdrant",
    embedding_model="text-embedding-3-large"
)

# Add documents
kb.add_pdf("manual.pdf")
kb.add_website("https://docs.example.com", max_pages=50)

# Create an agent with the knowledge base
agent = studio.create_agent(
    name="Support Bot",
    provider="gpt-4o",
    role="Customer support",
    goal="Answer questions using documentation",
    instructions="Use the knowledge base to answer questions accurately"
)

# Query with the knowledge base
response = agent.run(
    "How do I reset my password?",
    knowledge_bases=[kb]
)
print(response.response)
```

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

### Cognis get() Response Example

Source: https://docs.lyzr.ai/enterprise/lyzr-blocks/cognis/api/get-memories

Demonstrates how to access and print information from the `CognisMemoryList` object returned by the `get()` method.

```python
memories = cog.get(owner_id="user_alice")

print(len(memories))        # Number of memories returned
print(memories.total)       # Total count in the store
print(memories[0].content)  # Access by index
```

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

### Quick Start: Add Various Document Types

Source: https://docs.lyzr.ai/enterprise/adk/knowledge-bases/adding-documents

Initialize the Studio, create a knowledge base, and add multiple document types including PDF, DOCX, TXT, websites, and custom text.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

kb = studio.create_knowledge_base(name="my_docs")

# Add various document types
kb.add_pdf("manual.pdf")
kb.add_docx("report.docx")
kb.add_txt("notes.txt")
kb.add_website("https://docs.example.com", max_pages=50)
kb.add_text("Custom FAQ content", source="faq")
```

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

### Quick Start: File and Image Generation

Source: https://docs.lyzr.ai/enterprise/adk/file-image-output/overview

This snippet demonstrates how to initialize the Studio, create agents for both file and image generation, and process their responses. Ensure you have your API key set and the necessary models imported.

```python
from lyzr import Studio
from lyzr.image_models import Gemini, DallE

studio = Studio(api_key="your-api-key")

# File generation
file_agent = studio.create_agent(
    name="Report Generator",
    provider="gpt-4o",
    role="Report creator",
    goal="Generate professional reports",
    file_output=True  # Enable file generation
)

response = file_agent.run("Create a Q4 sales report in PDF format")

if response.has_files():
    for file in response.files:
        print(f"Generated: {file.name} ({file.format_type})")
        file.download("./reports/q4_sales.pdf")

# Image generation
image_agent = studio.create_agent(
    name="Image Creator",
    provider="gpt-4o",
    role="Visual designer",
    goal="Create images",
    image_model=Gemini.PRO  # Enable image generation
)

response = image_agent.run("Create an image of a futuristic cityscape")

if response.has_files():
    for img in response.files:
        print(f"Image: {img.url}")
        img.download("./images/city.png")
```

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

### Example JSON for Task Breakdown Agent

Source: https://docs.lyzr.ai/enterprise/learn/cookbooks/software-manager

This JSON structure is used as an example for the Task Breakdown Agent to guide its output format for structured tasks.

```json
{
  "tasks": [
    {
      "name": "",
      "description": "",
      "dependencies": "",
      "priority": ""
    }
  ]
}
```

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

### Example Request Body for Neo4j Text Training

Source: https://docs.lyzr.ai/enterprise/lyzr-blocks/knowledge-base/api/neo4j-text

Provides an example of the JSON payload required to start a Neo4j text training task. Ensure 'rag_id' and 'text' are provided.

```json
{
  "rag_id": "654c602a46c3b6d4e28741b0",
  "text": "The main product is Gemini. It is an AI model.",
  "schema_prompt": "Focus only on products and models as nodes."
}
```

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

### Detailed Image Prompt Example

Source: https://docs.lyzr.ai/lyzr-adk/file-image-output/image-generation

Use detailed descriptions to guide the image generation process for specific outcomes. This example shows how to specify elements like lighting, furniture, and style.

```python
response = agent.run("""
Create an image of a modern office space:
- Large windows with city view
- Minimalist furniture in neutral colors
- Green plants for accents
- Natural lighting
- A few people working at desks
- Style: Photorealistic
""")
```

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

### Quick Start: Query Knowledge Base and Use with Agent

Source: https://docs.lyzr.ai/enterprise/adk/knowledge-bases/querying

Initialize the Studio, retrieve a knowledge base, and then query it directly or pass it to an agent for RAG-powered responses. Ensure you replace 'your-api-key' and 'kb_id' with your actual credentials and knowledge base ID.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

# Get a knowledge base
kb = studio.get_knowledge_base("kb_id")

# Query directly
results = kb.query("What is the return policy?", top_k=5)
for result in results:
    print(f"{result.score:.2f}: {result.text[:100]}...")

# Use with an agent
agent = studio.create_agent(name="Support", provider="gpt-4o")
response = agent.run(
    "What is the return policy?",
    knowledge_bases=[kb]
)
```

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

### Example Managerial Context for a Policy Pro Insight Sub-agent

Source: https://docs.lyzr.ai/enterprise/agent-studio/manageragent/studio

Provide a plain-English instruction to guide the Manager Agent on when to invoke a specific sub-agent. This example specifies conditions for invoking an HR policy-related agent.

```text
Invoke this agent when the user asks any question about HR policies,
leave entitlements,
benefits, or anything that can be answered from the employee handbook.
Do not invoke
for questions about specific employee data or calculations.
```

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

### Quick Start: Generate a PDF Report

Source: https://docs.lyzr.ai/enterprise/adk/file-image-output/file-generation

Demonstrates how to create an agent with file output enabled and run a prompt to generate a PDF project status report. Shows how to access and download the generated files.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

# Create agent with file output enabled
agent = studio.create_agent(
    name="Document Generator",
    provider="gpt-4o",
    role="Professional document creator",
    goal="Generate well-formatted documents",
    instructions="Create professional documents in the requested format",
    file_output=True  # Enable file generation
)

# Generate a PDF report
response = agent.run("Create a project status report in PDF format")

# Access generated files
if response.has_files():
    for file in response.files:
        print(f"Generated: {file.name} ({file.format_type})")
        print(f"Download URL: {file.url}")
        file.download(f"./output/{file.name}")
```

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

### Create Basic Knowledge Base

Source: https://docs.lyzr.ai/lyzr-adk/knowledge-bases/creating-kb

Creates a new knowledge base with default settings. This is the simplest way to get started.

```APIDOC
## create_knowledge_base(name: str)

### Description
Creates a new knowledge base with a specified name and default configurations for vector store, embedding model, and LLM model.

### Method Signature
```python
studio.create_knowledge_base(name: str)
```

### Parameters
#### Path Parameters
- **name** (str) - Required - The name for the new knowledge base.

### Request Example
```python
kb = studio.create_knowledge_base(name="support_docs")
```
```

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

### Initialize Lyzr Studio and Add Documents

Source: https://docs.lyzr.ai/lyzr-adk/knowledge-bases/adding-documents

Demonstrates initializing the Studio client and adding multiple document types to a knowledge base.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

kb = studio.create_knowledge_base(name="my_docs")

# Add various document types
kb.add_pdf("manual.pdf")
kb.add_docx("report.docx")
kb.add_txt("notes.txt")
kb.add_website("https://docs.example.com", max_pages=50)
kb.add_text("Custom FAQ content", source="faq")
```

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

### Quick Start Knowledge Base Management

Source: https://docs.lyzr.ai/lyzr-adk/knowledge-bases/managing-kb

Initializes the Lyzr Studio client and demonstrates basic lifecycle operations for knowledge bases and documents.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

# List all knowledge bases
kbs = studio.list_knowledge_bases()
for kb in kbs:
    print(f"{kb.id}: {kb.name}")

# Get a specific knowledge base
kb = studio.get_knowledge_base("kb_id")

# List documents
docs = kb.list_documents()

# Delete specific documents
kb.delete_documents(["doc_id_1", "doc_id_2"])

# Reset (clear all documents)
kb.reset()

# Delete the knowledge base
kb.delete()
```

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

### Get RAG Configuration Request Example

Source: https://docs.lyzr.ai/enterprise/lyzr-blocks/knowledge-base/api/get-config

Use this cURL command to retrieve the configuration of a RAG instance by its ID. Ensure you include your API key in the header.

```bash
curl -X GET "https://rag-dev.test.studio.lyzr.ai/v3/rag/8544/" \
-H "accept: application/json" \
-H "x-api-key: sk-default-Bk19s6ZUGIBoBkJNdkJ8YfcPLwULRXcH"
```

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

### Python Request to Get Agents

Source: https://docs.lyzr.ai/enterprise/api/agents/get-by-key

This Python script demonstrates how to fetch agents using the requests library. Ensure you have the library installed and replace 'sk-default-XXXXXXX' with your actual API key.

```python
import requests

url = "https://agent-prod.studio.lyzr.ai/v3/agents/"
headers = {
    "accept": "application/json",
    "x-api-key": "sk-default-XXXXXXX"
}

response = requests.get(url, headers=headers)
print(response.status_code)
print(response.json())  # Print response data
```

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

### Quick Start Knowledge Base Querying

Source: https://docs.lyzr.ai/lyzr-adk/knowledge-bases/querying

Initialize the Lyzr Studio, retrieve a knowledge base, and perform direct queries or use it within an agent.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

# Get a knowledge base
kb = studio.get_knowledge_base("kb_id")

# Query directly
results = kb.query("What is the return policy?", top_k=5)
for result in results:
    print(f"{result.score:.2f}: {result.text[:100]}...")

# Use with an agent
agent = studio.create_agent(name="Support", provider="gpt-4o")
response = agent.run(
    "What is the return policy?",
    knowledge_bases=[kb]
)
```

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

### Create and Run Agent with a Single Knowledge Base

Source: https://docs.lyzr.ai/lyzr-adk/agents/running-agents

Demonstrates creating a knowledge base from a PDF and a website, then creating an agent and running it with the knowledge base passed at runtime.

```python
import lyzr

studio = lyzr.Studio()

# Create knowledge base
kb = studio.create_knowledge_base(name="Product Docs")
kb.add_pdf("manual.pdf")
kb.add_website("https://docs.example.com")

# Create agent (without KB)
agent = studio.create_agent(
    name="Support Bot",
    provider="gpt-4o",
    role="Support agent",
    goal="Answer product questions",
    instructions="Use the knowledge base to answer questions"
)

# Pass KB at runtime
response = agent.run(
    "How do I reset my password?",
    knowledge_bases=[kb]
)
```

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

### Quick Start: Manage Agents

Source: https://docs.lyzr.ai/enterprise/adk/agents/managing-agents

Perform common agent management operations including getting, updating, cloning, and deleting an agent. Requires initializing the Studio with an API key.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

# Get an existing agent
agent = studio.get_agent("agent_id")

# Update the agent
agent = agent.update(temperature=0.5)

# Clone the agent
cloned = agent.clone("My Cloned Agent")

# Delete the agent
agent.delete()
```

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

### Adding Documents to Knowledge Base

Source: https://docs.lyzr.ai/lyzr-adk/knowledge-bases/adding-documents

This section provides an overview and quick start guide for adding various document types to a Lyzr AI knowledge base. Documents are automatically processed for retrieval.

```APIDOC
## Adding Documents

Add PDFs, websites, and other content to knowledge bases using methods like `add_pdf()`, `add_website()`, and `add_text()`. Documents are automatically chunked and vectorized for retrieval.

### Quick Start

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

kb = studio.create_knowledge_base(name="my_docs")

# Add various document types
kb.add_pdf("manual.pdf")
kb.add_docx("report.docx")
kb.add_txt("notes.txt")
kb.add_website("https://docs.example.com", max_pages=50)
kb.add_text("Custom FAQ content", source="faq")
```
```

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

### Create Knowledge Base and Add Documents

Source: https://docs.lyzr.ai/enterprise/adk/knowledge-bases/creating-kb

Shows how to create a knowledge base, add PDF and website documents, and then use the knowledge base with an agent. This is a common workflow after initial setup.

```python
kb = studio.create_knowledge_base(name="my_kb")

# Add documents
kb.add_pdf("manual.pdf")
kb.add_website("https://docs.example.com")

# Use with an agent
response = agent.run("Question?", knowledge_bases=[kb])
```

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

### Quick Start: Hosted Lyzr ADK with CrewAI

Source: https://docs.lyzr.ai/cognis/cookbooks/cognis-crewai

This example demonstrates how to use the hosted Lyzr ADK to retrieve user preferences, inject them into a CrewAI agent's backstory, run the crew, and store the results.

```python
from lyzr import Cognis, CognisMessage
from crewai import Agent, Task, Crew

cog = Cognis()

# 1. Retrieve user preferences
memories = cog.search(query="travel preferences", owner_id="user_123", limit=5)
memory_context = "\n".join(f"- {m.content}" for m in memories)

# 2. Inject memories into agent backstory
agent = Agent(
    role="Travel Researcher",
    goal="Find the best travel options",
    backstory=f"You know this about the user:\n{memory_context}",
)

# 3. Run the crew
task = Task(description="Research beach destinations", expected_output="Top 3 destinations", agent=agent)
crow = Crew(agents=[agent], tasks=[task])
result = crew.kickoff()

# 4. Store the result
cog.add(
    messages=[
        CognisMessage(role="user", content="Plan a beach vacation"),
        CognisMessage(role="assistant", content=str(result)),
    ],
    owner_id="user_123",
    agent_id="travel_crew",
)

```

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

### Create a Basic Agent

Source: https://docs.lyzr.ai/enterprise/adk/agents/creating-agents

Instantiate a Studio object with your API key and then create a new agent with essential configurations like name, provider, role, goal, and instructions.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

agent = studio.create_agent(
    name="Support Bot",
    provider="gpt-4o",
    role="Customer support agent",
    goal="Help customers resolve their issues",
    instructions="Be empathetic, clear, and solution-oriented"
)
```

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

### Quick Start: Hosted (lyzr-adk) Chatbot with Memory

Source: https://docs.lyzr.ai/cognis/cookbooks/cognis-langchain

This example demonstrates how to use Lyzr Cognis with the lyzr-adk for a hosted integration. It searches for user preferences, builds a LangChain chain with memory context, and stores the interaction.

```python
from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from lyzr import Cognis, CognisMessage

cog = Cognis()
llm = ChatOpenAI(model="gpt-4o")

# Search for relevant memories
results = cog.search(query="user preferences", owner_id="user_123", limit=5)
memory_text = "\n".join(f"- {r.content}" for r in results)

# Build chain with memory context
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    MessagesPlaceholder(variable_name="memory_context"),
    ("human", "{input}"),
])
chain = prompt | llm

# Invoke with memory
response = chain.invoke({
    "input": "What should I cook tonight?",
    "memory_context": [SystemMessage(content=f"User memories:\n{memory_text}")] if results else [],
})

# Store the interaction
cog.add(
    messages=[
        CognisMessage(role="user", content="What should I cook tonight?"),
        CognisMessage(role="assistant", content=response.content),
    ],
    owner_id="user_123",
)
```

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

### Create Agent and Add Features

Source: https://docs.lyzr.ai/enterprise/adk/agents/agent-features

Quickly set up an agent with basic configurations and add memory.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

agent = studio.create_agent(
    name="Assistant",
    provider="gpt-4o",
    role="Helpful assistant",
    goal="Help users",
    instructions="Be helpful and accurate"
)

# Add features
agent = agent.add_memory(30)
agent.add_tool(my_function)
```

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

### Initialize Studio with .env File

Source: https://docs.lyzr.ai/enterprise/adk/overview

Initialize the Studio without arguments; it will automatically load the API key from the .env file.

```python
studio = Studio()  # Auto-loads from .env
```

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

### Quick Start: Hosted Lyzr ADK Chatbot with Memory

Source: https://docs.lyzr.ai/cognis/cookbooks/cognis-langgraph

Build a support chatbot using Lyzr ADK and LangGraph. This example defines retrieve, respond, and store functions to manage memory context within the graph.

```python
from langgraph.graph import StateGraph, END
from lyzr import Cognis, CognisMessage

cog = Cognis()

def retrieve(state):
    results = cog.search(query=state["user_input"], owner_id=state["owner_id"], limit=5)
    return {"memory_context": "\n".join(f"- {r.content}" for r in results)}

def respond(state):
    # Your LLM call here, using state["memory_context"]
    return {"response": "..."}

def store(state):
    cog.add(
        messages=[
            CognisMessage(role="user", content=state["user_input"]),
            CognisMessage(role="assistant", content=state["response"]),
        ],
        owner_id=state["owner_id"],
    )
    return {}

graph = StateGraph(dict)
graph.add_node("retrieve", retrieve)
graph.add_node("respond", respond)
graph.add_node("store", store)
graph.set_entry_point("retrieve")
graph.add_edge("retrieve", "respond")
graph.add_edge("respond", "store")
graph.add_edge("store", END)
app = graph.compile()
```

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

### Quick Start: Open Source Lyzr Cognis with CrewAI

Source: https://docs.lyzr.ai/cognis/cookbooks/cognis-crewai

This example shows how to use the open-source Lyzr Cognis to retrieve user preferences, inject them into a CrewAI agent's backstory, run the crew, and store the results.

```python
from cognis import Cognis
from crewai import Agent, Task, Crew

m = Cognis(owner_id="user_123", agent_id="travel_crew")

# 1. Retrieve user preferences
resp = m.search("travel preferences", limit=5)
memory_context = "\n".join(f"- {r['content']}" for r in resp["results"])

# 2. Inject memories into agent backstory
agent = Agent(
    role="Travel Researcher",
    goal="Find the best travel options",
    backstory=f"You know this about the user:\n{memory_context}",
)

# 3. Run the crew
task = Task(description="Research beach destinations", expected_output="Top 3 destinations", agent=agent)
crow = Crew(agents=[agent], tasks=[task])
result = crew.kickoff()

# 4. Store the result
m.add([
    {"role": "user", "content": "Plan a beach vacation"},
    {"role": "assistant", "content": str(result)},
])

m.close()

```

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

### Create Agent with Image Generation (Gemini)

Source: https://docs.lyzr.ai/enterprise/adk/file-image-output/image-generation

Quick start example demonstrating how to create a Lyzr agent with image generation capabilities enabled using the Gemini Pro model. Shows how to run the agent and access/download generated images.

```python
from lyzr import Studio
from lyzr.image_models import Gemini, DallE

studio = Studio(api_key="your-api-key")

# Create agent with image generation
agent = studio.create_agent(
    name="Image Creator",
    provider="gpt-4o",
    role="Visual designer",
    goal="Create images from descriptions",
    image_model=Gemini.PRO  # Enable image generation
)

# Generate an image
response = agent.run("Create an image of a futuristic city at sunset")

# Access generated images
if response.has_files():
    for img in response.files:
        print(f"Image URL: {img.url}")
        img.download("./images/city.png")
```

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

### Using the Studio Context Manager

Source: https://docs.lyzr.ai/enterprise/adk/overview

Demonstrates how to use the Studio context manager for automatic cleanup of resources. Ensure you have your API key ready.

```python
with Studio(api_key="your-api-key") as studio:
    agent = studio.create_agent(...)
    response = agent.run("Hello")
# Connection automatically closed
```

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

### Quick Start: Open Source (lyzr-cognis) Chatbot with Memory

Source: https://docs.lyzr.ai/cognis/cookbooks/cognis-langchain

This example demonstrates how to use Lyzr Cognis with the lyzr-cognis package for an open-source integration. It searches for user preferences, builds a LangChain chain with memory context, and stores the interaction.

```python
from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from cognis import Cognis

m = Cognis(owner_id="user_123")
llm = ChatOpenAI(model="gpt-4o")

# Search for relevant memories
resp = m.search("user preferences", limit=5)
memory_text = "\n".join(f"- {r['content']}" for r in resp["results"])

# Build chain with memory context
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    MessagesPlaceholder(variable_name="memory_context"),
    ("human", "{input}"),
])
chain = prompt | llm

# Invoke with memory
response = chain.invoke({
    "input": "What should I cook tonight?",
    "memory_context": [SystemMessage(content=f"User memories:\n{memory_text}")] if resp["results"] else [],
})

# Store the interaction
m.add([
    {"role": "user", "content": "What should I cook tonight?"},
    {"role": "assistant", "content": response.content},
])

m.close()
```

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

### Studio Initialization Parameters

Source: https://docs.lyzr.ai/enterprise/adk/studio

Demonstrates different ways to initialize the Studio class, including providing an API key directly, using an environment variable, or enabling debug logging.

```python
Studio(
    api_key: str = None,      # API key (or use LYZR_API_KEY env var)
    log: str = "warning"      # Logging level
)
```

```python
from lyzr import Studio

# With explicit API key
studio = Studio(api_key="sk-xxx")

# Using environment variable
import os
os.environ["LYZR_API_KEY"] = "sk-xxx"
studio = Studio()

# With debug logging
studio = Studio(api_key="sk-xxx", log="debug")
```

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

### Example Slack Bot Commands

Source: https://docs.lyzr.ai/enterprise/learn/cookbooks/slack

Demonstrates how to list available agents and switch between them using Slack commands.

```bash
/agents
→ Available agents (use /switch <name> to select one):
  • Support Agent — 67e4d6983e456a9f92912044
  • Sales Agent — 67e4d6673e456a9f9291203d

/switch Sales Agent
→ Switched to agent 'Sales Agent'. How can I help you?
```

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

### Quick Start: Pydantic Model for Product Information

Source: https://docs.lyzr.ai/enterprise/adk/structured-outputs/structured-outputs

Define a Pydantic model to structure agent responses and extract typed data. This example shows how to create an agent, run it with a Pydantic model as the response format, and access the structured output.

```python
from lyzr import Studio
from pydantic import BaseModel, Field

studio = Studio(api_key="your-api-key")

# Define your output structure
class ProductInfo(BaseModel):
    name: str = Field(description="Product name")
    price: float = Field(description="Price in USD")
    in_stock: bool = Field(description="Whether item is in stock")
    features: list[str] = Field(description="List of key features")

# Create agent
agent = studio.create_agent(
    name="Product Analyzer",
    provider="gpt-4o",
    role="Product information extractor",
    goal="Extract structured product data"
)

# Run with structured output
response = agent.run(
    "The iPhone 15 Pro costs $999 and has a titanium design, A17 chip, and USB-C. Currently available.",
    response_format=ProductInfo
)

# Access typed data
product = response.structured_output
print(f"Name: {product.name}")        # "iPhone 15 Pro"
print(f"Price: ${product.price}")     # "$999.0"
print(f"In Stock: {product.in_stock}")  # True
print(f"Features: {product.features}")  # ["titanium design", "A17 chip", "USB-C"]

```

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

### Quick Start: Create and Add Context to Agent

Source: https://docs.lyzr.ai/enterprise/adk/contexts/contexts

Demonstrates how to create a context with company information and add it to an agent. The agent can then use this context to answer questions.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

# Create a context
context = studio.create_context(
    name="company_info",
    value="Acme Corp is a technology company founded in 2020. We specialize in AI solutions."
)

# Add context to agent
agent = studio.create_agent(
    name="Support Bot",
    provider="gpt-4o",
    role="Customer support",
    goal="Help customers with inquiries"
)
agent.add_context(context)

# Agent now has company info available
response = agent.run("What does your company do?")
# Uses company_info context to answer
```

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

### Quick Start: Open Source Lyzr Cognis Chatbot with Memory

Source: https://docs.lyzr.ai/cognis/cookbooks/cognis-langgraph

Build a support chatbot using open-source Lyzr Cognis and LangGraph. This example defines retrieve, respond, and store functions to manage memory context within the graph.

```python
from langgraph.graph import StateGraph, END
from cognis import Cognis

m = Cognis(owner_id="default_user")

def retrieve(state):
    resp = m.search(state["user_input"], owner_id=state.get("owner_id"), limit=5)
    return {"memory_context": "\n".join(f"- {r['content']}" for r in resp["results"]) } 

def respond(state):
    # Your LLM call here, using state["memory_context"]
    return {"response": "..."}

def store(state):
    m.add([
        {"role": "user", "content": state["user_input"]},
        {"role": "assistant", "content": state["response"]},
    ], owner_id=state.get("owner_id"))
    return {}

graph = StateGraph(dict)
graph.add_node("retrieve", retrieve)
graph.add_node("respond", respond)
graph.add_node("store", store)
graph.set_entry_point("retrieve")
graph.add_edge("retrieve", "respond")
graph.add_edge("respond", "store")
graph.add_edge("store", END)
app = graph.compile()
```

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

### Complete Tools Settings Page Example

Source: https://docs.lyzr.ai/enterprise/learn/cookbooks/tooling

This React component demonstrates a full-page setup for managing tool connections, including account display, tool browsing, and connection modals. It utilizes state management for refreshing data and handling user interactions.

```tsx
// pages/ToolsSettings.tsx
export default function ToolsSettings() {
  const userId = "user@example.com"; // from your auth context
  const [selectedTool, setSelectedTool] = useState<Tool | null>(null);
  const [refreshKey, setRefreshKey] = useState(0);

  // Handle OAuth redirect callback
  useOAuthCallback(userId, () => setRefreshKey((k) => k + 1));

  return (
    <div className="max-w-5xl mx-auto py-10 px-4 space-y-10">
      <section>
        <h1 className="text-2xl font-bold mb-1">Tool Connections</h1>
        <p className="text-gray-500">Manage the tools available to your agents.</p>
      </section>

      <section>
        <h2 className="text-lg font-semibold mb-3">Connected Accounts</h2>
        <ConnectedAccounts key={refreshKey} userId={userId} />
      </section>

      <section>
        <h2 className="text-lg font-semibold mb-3">Available Tools</h2>
        <ToolBrowser onSelect={setSelectedTool} />
      </section>

      <ConnectToolModal
        tool={selectedTool}
        userId={userId}
        onClose={() => setSelectedTool(null)}
        onConnected={() => {
          setSelectedTool(null);
          setRefreshKey((k) => k + 1);
        }}
      />
    </div>
  );
}
```

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

### Delete Knowledge Base (example)

Source: https://docs.lyzr.ai/enterprise/adk/studio

Example of deleting a knowledge base by its ID.

```python
studio.delete_knowledge_base("kb_123")
```

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

### Agent Creation and File Output Example

Source: https://docs.lyzr.ai/enterprise/adk/responses/responses

Shows how to create an agent with file output enabled and run a task to generate a report. This snippet also demonstrates iterating through response files, printing their details, and downloading them.

```python
# Enable file output
agent = studio.create_agent(
    name="Report Generator",
    provider="gpt-4o",
    file_output=True
)

response = agent.run("Create a PDF report about Q1 sales")

# Download generated files
if response.has_files():
    for artifact in response.files:
        print(f"File: {artifact.name}")
        print(f"Format: {artifact.format_type}")
        print(f"URL: {artifact.url}")

        # Download to local file
        artifact.download(f"./downloads/{artifact.name}")
        print(f"Downloaded to ./downloads/{artifact.name}")
```

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

### Install lyzr-cognis

Source: https://docs.lyzr.ai/cognis/quickstart

Install the open-source version of Lyzr Cognis using pip.

```bash
pip install lyzr-cognis
```

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

### Install lyzr-adk

Source: https://docs.lyzr.ai/cognis/quickstart

Install the hosted version of Lyzr Cognis using pip.

```bash
pip install lyzr-adk
```

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

### Quick Start: Create a Knowledge Base

Source: https://docs.lyzr.ai/enterprise/adk/knowledge-bases/creating-kb

Use this snippet to quickly create a new knowledge base with specified name, vector store, embedding model, and LLM model. Ensure you have initialized the Studio with your API key.

```python
from lyzr import Studio

studio = Studio(api_key="your-api-key")

kb = studio.create_knowledge_base(
    name="product_docs",
    vector_store="qdrant",
    embedding_model="text-embedding-3-large",
    llm_model="gpt-4o",
    description="Product documentation knowledge base"
)

print(f"Created KB: {kb.id}")
```
Tokens:
Raw