Lyzr ADK

https://docs.lyzr.ai/lyzr-adk
Admin
Lyzr ADK is a Python library for building, deploying, and managing AI agents with features like RAG,...
Tokens:47,213
Snippets:423
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Quick Start: Create Knowledge Base, Add Documents, and Query with Agent

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

This comprehensive example demonstrates the full workflow: initializing the Studio, creating a knowledge base with specified vector store and embedding model, adding both PDF and website documents, creating an agent configured for customer support using the knowledge base, and finally running a query against the agent.

```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)
```

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

### Quick Start: Manage Knowledge Bases and Documents

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

Initialize the Studio, then perform common operations like listing knowledge bases, getting a specific one, listing its documents, deleting documents, resetting the knowledge base, and deleting the knowledge base itself.

```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()
```

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

### Quick Start: Manage Agents

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

Initialize the Studio, get an agent, update its temperature, clone it, and then delete it. Ensure you have your API key and agent ID.

```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()
```

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

### Document Q&A Setup and Query

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

Sets up a knowledge base with PDF documents and an agent to answer questions about them. Use this to query your documents and get specific answers.

```python
import lyzr

# Setup KB
kb = lyzr.create_knowledge_base(name="Documents")
kb.add_pdf("contract.pdf")
kb.add_pdf("guidelines.pdf")

# Create agent
agent = lyzr.create_agent(
    name="Doc Assistant",
    provider="gpt-4o",
    role="Document analyst",
    goal="Answer questions about documents",
    instructions="Cite specific sections when answering"
)

# Query documents
questions = [
    "What is the payment terms?",
    "What are the cancellation conditions?",
    "Summarize the key obligations"
]

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

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

### Create Knowledge Base Example

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

Example of creating a knowledge base named 'Product Documentation' using Qdrant as the vector store and 'text-embedding-3-large' as the embedding model.

```python
kb = studio.create_knowledge_base(
    name="Product Documentation",
    vector_store="qdrant",
    embedding_model="text-embedding-3-large"
)
```

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

### Quick Start: Initialize Studio and Create an Agent

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

Initialize the Studio with your API key, create a new agent with specified parameters, and run a simple interaction.

```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)
```

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

### Get Knowledge Base Example

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

Example of retrieving a knowledge base using its ID and printing 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/lyzr-adk/overview

Initialize the Studio with your API key, create an agent with specified parameters, and run a query. Ensure your API key is kept secure.

```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)
```

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

### Create Agent Example

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

Example of creating a customer support agent with a specified name, LLM provider, role, goal, and instructions.

```python
agent = studio.create_agent(
    name="Support Bot",
    provider="gpt-4o",
    role="Customer support",
    goal="Resolve issues quickly",
    instructions="Be empathetic and professional"
)
```

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

### Get Agent Example

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

Example of retrieving an agent using its ID and printing its name.

```python
agent = studio.get_agent("agent_123")
print(agent.name)
```

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

### Quick Start: Create Knowledge Base and Add Documents

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

Initialize the Studio, create a knowledge base, and add multiple document types. Ensure you have your API key and document files ready.

```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")
```

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

### List Knowledge Bases Example

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

Example of listing all knowledge bases and printing their IDs and names.

```python
kbs = studio.list_knowledge_bases()
for kb in kbs:
    print(f"{kb.id}: {kb.name}")
```

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

### Create a Knowledge Base with Full Configuration

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

This example demonstrates creating a knowledge base with all primary parameters specified: name, vector store, embedding model, LLM model, and a description.

```python
kb = studio.create_knowledge_base(
    name="enterprise_kb",
    vector_store="qdrant",
    embedding_model="text-embedding-3-large",
    llm_model="gpt-4o",
    description="Enterprise documentation for customer support"
)
```

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

### Create and Populate Knowledge Base - Support KB

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

Example of creating a knowledge base named 'support_kb' and populating it with support articles from a website, PDF manuals, and FAQ text.

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

# Add support articles
kb.add_website("https://support.example.com", max_pages=100)

# Add PDF manuals
kb.add_pdf("user_manual.pdf")
kb.add_pdf("troubleshooting_guide.pdf")

# Add FAQ text
kb.add_text(
    """
    Q: How do I reset my password?
    A: Click 'Forgot Password' on the login page and follow the instructions.

    Q: How do I contact support?
    A: Email support@example.com or call 1-800-EXAMPLE.
    """,
    source="faq"
)
```

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

### Studio Initialization Examples

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

Demonstrates different ways to initialize the Studio class, including providing an explicit API key, using an environment variable, and setting the logging level to debug.

```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")
```

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

### Create and Populate Knowledge Base - Product Docs

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

Example of creating a knowledge base named 'product_docs' and populating it with documentation from a website, API reference, and a PDF changelog.

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

# Add main documentation
kb.add_website(
    "https://docs.example.com",
    max_pages=200,
    max_depth=5
)

# Add API reference
kb.add_website(
    "https://api.example.com/docs",
    max_pages=50,
    max_depth=2
)

# Add changelog
kb.add_pdf("changelog.pdf")
```

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

### Agent Integration: Basic Usage with Knowledge Base

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

Configure and run a Lyzr agent, providing it with a knowledge base to answer user queries. This example shows basic agent setup and how to pass a single knowledge base for RAG.

```python
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 accurately"
)

response = agent.run(
    "What is the return policy?",
    knowledge_bases=[kb]
)
print(response.response)
```

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

### Agent Features Overview

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

This section provides a general overview of agent features and a quick start example for creating an agent and adding features.

```APIDOC
## Agent Features

Enhance agents with features like memory, local tools, contexts, RAI guardrails, file output, image generation, and evaluation capabilities.

### Quick Start

```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)
```
```

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

### List Agents Example

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

Example of listing all agents and printing their IDs and names.

```python
agents = studio.list_agents()
for agent in agents:
    print(f"{agent.id}: {agent.name}")
```

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

### Module Access Examples

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

Examples of accessing methods through dedicated modules.

```APIDOC
## Module Access

### Description
Access methods through dedicated modules for better organization.

### Code Examples
```python
studio = Studio(api_key="sk-xxx")

# Agent methods
agent = studio.agents.create(...)
agent = studio.agents.get(agent_id)
agents = studio.agents.list()

# Knowledge base methods
kb = studio.knowledge_bases.create(...)
kb = studio.knowledge_bases.get(kb_id)

# Context methods
ctx = studio.contexts.create(...)
ctx = studio.contexts.get(context_id)

# RAI methods
policy = studio.rai.create_policy(...)
policy = studio.rai.get_policy(policy_id)

# Memory methods
memory = studio.memory.create_credential(...)
```
```

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

### Create and Run an Agent

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

Initialize the Studio with your API key, create an agent with specified parameters, and run it to get a response. Ensure you replace 'your-api-key' with your actual key.

```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)
```

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

### Q&A Bot Example

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

Sets up a Q&A bot using a knowledge base and an agent to answer predefined questions. Ensure the knowledge base is correctly retrieved using `studio.get_knowledge_base()`.

```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")
```

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

### Create Knowledge Base with Different Vector Stores

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

Examples demonstrate creating knowledge bases using various vector store providers like Qdrant, Weaviate, PG Vector, Milvus, and Neptune.

```python
# Qdrant (default)
kb = studio.create_knowledge_base(
    name="docs_qdrant",
    vector_store="qdrant"
)

# Weaviate
kb = studio.create_knowledge_base(
    name="docs_weaviate",
    vector_store="weaviate"
)

# PG Vector (PostgreSQL)
kb = studio.create_knowledge_base(
    name="docs_postgres",
    vector_store="pg_vector"
)

# Milvus
kb = studio.create_knowledge_base(
    name="docs_milvus",
    vector_store="milvus"
)

# Amazon Neptune
kb = studio.create_knowledge_base(
    name="docs_neptune",
    vector_store="neptune"
)
```

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

### Create and Configure a Full-Featured Agent

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

This snippet demonstrates the comprehensive setup of an agent, including its name, provider, role, goal, instructions, memory, tools, context, RAI policies, file/image output, reflection, bias check, and groundedness facts. It concludes with verifying the enabled features and running a task.

```python
agent = studio.create_agent(
    name="Full-Featured Bot",
    provider="gpt-4o",
    role="Enterprise assistant",
    goal="Help with various tasks securely",
    instructions="Be helpful while maintaining security"
)

# Add memory
agent = agent.add_memory(50)

# Add tools
def search_docs(query: str) -> str:
    """Search internal documentation"""
    return f"Results for: {query}"

agent.add_tool(search_docs)

# Add context
company_ctx = studio.create_context(
    name="company",
    value="Acme Corp - Enterprise software"
)
agent = agent.add_context(company_ctx)

# Add RAI policy
policy = studio.create_rai_policy(
    name="EnterprisePolicy",
    description="Enterprise security",
    toxicity_threshold=0.2,
    secrets_detection=SecretsAction.BLOCK,
    pii_detection={
        PIIType.CREDIT_CARD: PIIAction.BLOCK,
        PIIType.SSN: PIIAction.BLOCK
    }
)
agent = agent.add_rai_policy(policy)

# Enable file and image output
agent = agent.enable_file_output()
agent = agent.set_image_model(DallE.DALL_E_3)

# Enable evaluation features
agent = agent.enable_reflection()
agent = agent.enable_bias_check()

# Add groundedness facts
agent = agent.add_groundedness_facts([
    "Product launched in 2020",
    "Over 1000 enterprise customers"
])

# Verify features
print(f"Memory: {agent.has_memory()}")
print(f"RAI: {agent.has_rai_policy()}")
print(f"File output: {agent.has_file_output()}")
print(f"Image output: {agent.has_image_output()}")
print(f"Reflection: {agent.has_reflection()}")
print(f"Bias check: {agent.has_bias_check()}")
print(f"Groundedness: {agent.has_groundedness()}")

# Use the fully-featured agent
response = agent.run("Create a product overview document")
```

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

### Create Groq Agents

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

Use these examples to create agents with different Groq models. Specify the desired model using the `provider` argument.

```python
# Llama 3.3 70B - versatile
agent = studio.create_agent(provider="llama-3.3-70b-versatile")

# Llama 4 Maverick - 1M context
agent = studio.create_agent(provider="llama-4-maverick-17b-128e-instruct")

# Kimi K2
agent = studio.create_agent(provider="kimi-k2-instruct")
```

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

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

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

Initialize the Studio, retrieve a knowledge base, query it directly for specific information, and then use the same knowledge base with a Lyzr agent for RAG-powered responses.

```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]
)
```

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

### Q&A Bot Example

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

An example demonstrating how to create a Q&A bot using an agent and a knowledge base to answer frequently asked questions.

```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")
```
```

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

### Install Lyzr ADK

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

Install the Lyzr ADK using pip. This is the first step to begin using the library.

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

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

### Create a Basic Knowledge Base

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

A simple example of creating a knowledge base with only a name. Default settings for vector store, embedding model, and LLM model will be used.

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

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

### Backup and Recreate Knowledge Base

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

This example demonstrates migrating a knowledge base by creating a new one with the same configuration as an old one, adding documents to the new KB, and then deleting the old KB.

```python
old_kb = studio.get_knowledge_base("old_kb_id")

new_kb = studio.create_knowledge_base(
    name=f"{old_kb.name}_v2",
    vector_store="qdrant",
    embedding_model=old_kb.embedding_model,
    llm_model=old_kb.llm_model,
    description=old_kb.description
)

new_kb.add_website("https://docs.example.com")
new_kb.add_pdf("manual.pdf")

old_kb.delete()

print(f"Migrated to new KB: {new_kb.id}")
```

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

### Bulk Delete Agents Example

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

Example of deleting multiple agents by providing a list of their IDs.

```python
studio.bulk_delete_agents(["agent_1", "agent_2", "agent_3"])
```

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

### Document Search Example

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

An example showcasing how to perform document search using a knowledge base's query method to find relevant sections.

```APIDOC
### Document Search

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

# Search for relevant content
results = kb.query(
    "authentication flow",
    top_k=10,
    score_threshold=0.5
)

print(f"Found {len(results)} relevant sections:\n")

for i, result in enumerate(results, 1):
    print(f"{i}. [{result.score:.2f}] {result.source}")
    print(f"   {result.text[:150]}...\n")
```
```

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

### Create Agent with Short Provider Format

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

Use the short format to let the ADK auto-resolve the AI provider. This is useful for quick agent setup.

```python
agent = studio.create_agent(provider="gpt-4o")        # → OpenAI
agent = studio.create_agent(provider="claude-sonnet-4.5")  # → Anthropic
agent = studio.create_agent(provider="gemini-2.5-pro")     # → Google
```

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

### Comparison Search Example

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

Demonstrates how to use MMR (Maximum Marginal Relevance) for comparison searches to retrieve diverse results.

```APIDOC
### Comparison Search

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

# Use MMR for diverse results
results = kb.query(
    "compare product features",
    top_k=5,
    retrieval_type="mmr"
)

# Results will cover different aspects rather than similar content
for result in results:
    print(f"- {result.text[:100]}...")
```
```

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

### Create Knowledge Base with Different LLM Models

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

Configure the LLM model used for query processing. Examples include the default `gpt-4o` and the faster, cheaper `gpt-4o-mini`.

```python
# GPT-4o (default)
kb = studio.create_knowledge_base(
    name="my_kb",
    llm_model="gpt-4o"
)

# GPT-4o Mini (faster, cheaper)
kb = studio.create_knowledge_base(
    name="my_kb",
    llm_model="gpt-4o-mini"
)
```

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

### Error Handling Example

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

Demonstrates how to handle potential validation and API errors when creating a knowledge base.

```APIDOC
## Error Handling

### Description
This section shows how to catch and handle common errors like `ValidationError` and `APIError` when interacting with the knowledge base API.

### Example
```python
from lyzr.exceptions import ValidationError, APIError

try:
    kb = studio.create_knowledge_base(
        name="Invalid Name!",  # Invalid characters
        vector_store="unknown_store"  # Unknown provider
    )
except ValidationError as e:
    print(f"Validation error: {e.message}")
except APIError as e:
    print(f"API error: {e.message}")
```

### Potential Errors
- **ValidationError**: Raised when input parameters do not meet the required format or constraints.
- **APIError**: Raised for general API-related issues, such as network problems or server errors.
```

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

### Example: Detailed kb.query() with Score Threshold

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

Demonstrates how to query a knowledge base with specific parameters like query string, top_k, and a score threshold to filter results. It also shows how to access score, source, and text from the returned QueryResult objects.

```python
results = kb.query(
    "How do I reset my password?",
    top_k=5,
    score_threshold=0.5
)

for result in results:
    print(f"Score: {result.score:.2f}")
    print(f"Source: {result.source}")
    print(f"Text: {result.text[:200]}...")
    print("---")
```

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

### Create OpenAI Agents

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

Examples for creating agents with different OpenAI models, including GPT-4o for balanced performance, GPT-4o Mini for speed, GPT-5 for advanced reasoning, and O3 for reasoning tasks.

```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")
```

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

### Create and Populate Knowledge Base - Mixed Content

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

Example of creating a knowledge base named 'company_kb' and populating it with a mix of content types including internal PDFs, DOCX files, external websites, and dynamic text metrics.

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

# Internal documents
kb.add_pdf("employee_handbook.pdf")
kb.add_docx("policies.docx")

# External content
kb.add_website("https://blog.company.com", max_pages=50)

# Dynamic content
kb.add_text(
    f"Current quarter: Q1 2024\nRevenue target: $10M",
    source="metrics"
)
```

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

### Create AWS Bedrock Agents

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

Examples for creating agents using AWS Bedrock. The `provider` argument requires a specific format, often including the AWS account or service prefix.

```python
# Amazon Nova Pro
agent = studio.create_agent(provider="aws-bedrock/amazon.nova-pro-v1:0")

# Claude on Bedrock
agent = studio.create_agent(provider="bedrock/anthropic.claude-3-7-sonnet-20250219-v1:0")

# Llama on Bedrock
agent = studio.create_agent(provider="aws/meta.llama3-3-70b-instruct-v1:0")
```

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

### Manage Documents in a Knowledge Base

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

This example shows how to list documents in a knowledge base, remove specific outdated documents based on their source, and add a new version of a document. It concludes by verifying the document count after the update.

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

docs = kb.list_documents()
print(f"Current documents: {len(docs)}")

outdated = [doc.id for doc in docs if "v1" in doc.source]
if outdated:
    kb.delete_documents(outdated)

kb.add_pdf("manual_v2.pdf")

new_docs = kb.list_documents()
print(f"Documents after update: {len(new_docs)}")
```

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

### Add Raw Text Content

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

Shows how to add raw text content directly to the knowledge base. Includes examples for single text entries and iterating through a list of questions and answers to add them as text.

```python
kb.add_text(
    "Q: What are your business hours?\nA: We're open 9am-5pm PST, Monday-Friday.",
    source="faq"
)
```

```python
faqs = [
    ("What is your return policy?", "30-day money-back guarantee"),
    ("How do I contact support?", "Email support@example.com"),
    ("What payment methods do you accept?", "Visa, Mastercard, PayPal")
]

for question, answer in faqs:
    kb.add_text(
        f"Q: {question}\nA: {answer}",
        source="faq"
    )
```

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

### Create Google Gemini Agents

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

Examples for creating agents with Google Gemini models, including Gemini 2.5 Pro for advanced capabilities, Gemini 2.0 Flash for speed with a large context window, and Gemini 3 Pro Preview for the latest features.

```python
# Gemini 2.5 Pro - advanced
agent = studio.create_agent(provider="gemini-2.5-pro")

# Gemini Flash - fast with 1M context
agent = studio.create_agent(provider="gemini-2.0-flash")

# Gemini 3 Pro Preview - latest
agent = studio.create_agent(provider="gemini-3-pro-preview")
```

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

### Delete Agent Example

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

Example of deleting an agent using its ID.

```python
studio.delete_agent("agent_123")
```

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

### Time-Sensitive Search Example

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

An example illustrating how to prioritize recent content in search results using the `time_aware` retrieval type and `time_decay_factor`.

```APIDOC
### Time-Sensitive Search

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

# Prioritize recent content
results = kb.query(
    "market trends",
    retrieval_type="time_aware",
    time_decay_factor=0.8,
    top_k=5
)
```
```

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

### Create a Basic Agent

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

Instantiate the Studio and create a new agent with essential parameters like name, provider, role, and goal. Ensure you have your API key.

```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"
)
```

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

### Initialize Studio with .env File

Source: https://docs.lyzr.ai/lyzr-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
```

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

### Get Agent

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

Retrieve a specific agent by its unique identifier.

```APIDOC
## GET /api/agents/{agent_id}

### Description
Retrieve an agent by its ID.

### Method
GET

### Endpoint
/api/agents/{agent_id}

### Parameters
#### Path Parameters
- **agent_id** (str) - Required - The agent's unique identifier

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

### Response Example
```json
{
  "id": "agent_abc123",
  "name": "Example Agent",
  "provider": "openai",
  "model": "gpt-4",
  "temperature": 0.7
}
```
```

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

### Get Context

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

Retrieves a specific context using its unique ID.

```python
context = studio.get_context(context_id: str)
```

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

### Initialize Studio and Configure Agent with API Key

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

Set up the Lyzr Studio with your API key and import necessary components for agent creation, PII handling, and image generation. This is a foundational step for using advanced features.

```python
from lyzr import Studio, PIIType, PIIAction, SecretsAction
from lyzr.image_models import DallE

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

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

### Get RAI Policy

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

Retrieves a specific Responsible AI policy by its ID.

```python
policy = studio.get_rai_policy(policy_id: str)
```

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

### Get Knowledge Base

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

Retrieve a specific knowledge base by its unique identifier.

```APIDOC
## Get Knowledge Base

Retrieve a knowledge base by ID.

### Method
GET

### Endpoint
`/knowledge-bases/{kb_id}`

### Parameters
#### Path Parameters
- **kb_id** (str) - Required - The unique identifier of the knowledge base.

### Response
#### Success Response (200)
- **KnowledgeBase** (object) - An object representing the knowledge base.
  - **id** (str) - Knowledge base ID.
  - **name** (str) - Knowledge base name.
  - **description** (str) - Knowledge base description.
  - **vector_store_provider** (str) - The vector store provider used.
  - **embedding_model** (str) - The embedding model used.
  - **llm_model** (str) - The LLM model used.
  - **created_at** (str) - Timestamp of creation.

### Request Example
```python
kb = studio.get_knowledge_base(kb_id="kb_abc123")

print(f"Name: {kb.name}")
print(f"Vector Store: {kb.vector_store_provider}")
print(f"Embedding: {kb.embedding_model}")
print(f"LLM: {kb.llm_model}")
```
```

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

### Equivalent Agent Creation with Provider Formats

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

Demonstrates that specifying the provider using the short format ('gpt-4o') is equivalent to using the full format ('openai/gpt-4o').

```python
# These are equivalent
agent = studio.create_agent(provider="gpt-4o")
agent = studio.create_agent(provider="openai/gpt-4o")
```

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

### Create and Run an Agent

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

Initialize the Lyzr Studio with your API key, then create an agent with specified parameters like name, provider, role, goal, and instructions. Finally, run the agent with a user query and print the response.

```python
from lyzr import Studio

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

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

# Run the agent
response = agent.run("I can't login to my account")
print(response.response)
```

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

### Get Agent Method Signature

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

Retrieves an existing agent by its unique identifier.

```python
agent = studio.get_agent(agent_id: str)
```

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

### Provide API Key Directly

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

Initialize the Studio by passing your API key directly as a parameter. Keep your API key confidential.

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

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

### Get Knowledge Base Method Signature

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

Retrieves a specific knowledge base by its unique identifier.

```python
kb = studio.get_knowledge_base(kb_id: str)
```

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

### Get Agent Memory Configuration

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

Retrieve the current memory configuration, including the maximum number of messages to remember.

```python
config = agent.get_memory_config()
if config:
    print(f"Max messages: {config['max_messages_context_count']}")
```

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

### Create Knowledge Base Configurations

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

Demonstrates creating different `KnowledgeBaseRuntimeConfig` objects for specific retrieval needs, such as high precision, diverse results, or prioritizing recent content.

```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])
```

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

### Get Agent by ID

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

Retrieve a specific agent using its unique identifier. This is useful for fetching agent details before performing other operations.

```python
agent = studio.get_agent(agent_id: str) -> Agent
```

```python
agent = studio.get_agent("agent_abc123")

print(f"Name: {agent.name}")
print(f"Model: {agent.provider}/{agent.model}")
print(f"Temperature: {agent.temperature}")
```

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

### Create Knowledge Base

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

Use `studio.create_knowledge_base` to initialize a new knowledge base for storing company policies.

```python
policy_kb = studio.create_knowledge_base(
    name="policy_docs",
    description="Company policies and procedures"
)
```

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

### Initialize Studio with Environment Variable

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

Initialize the Studio without arguments; it will automatically load the API key from the LYZR_API_KEY environment variable.

```python
studio = Studio()  # Reads from LYZR_API_KEY
```

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

### Time-Sensitive Search Example

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

Employs the `time_aware` retrieval type to prioritize recent content. Adjust `time_decay_factor` to control the influence of content recency on search results.

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

# Prioritize recent content
results = kb.query(
    "market trends",
    retrieval_type="time_aware",
    time_decay_factor=0.8,
    top_k=5
)
```

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

### Create Multiple Knowledge Bases

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

Shows how to create distinct knowledge bases for different purposes, such as product documentation and FAQs, by calling `create_knowledge_base` multiple times with unique names and descriptions.

```python
# Product documentation
product_kb = studio.create_knowledge_base(
    name="product_docs",
    description="Product manuals and guides"
)

# FAQ knowledge base
faq_kb = studio.create_knowledge_base(
    name="faq_kb",
    description="Frequently asked questions"
)
```

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

### Get Knowledge Base by ID

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

Retrieve a specific knowledge base object using its unique ID. This is useful for performing subsequent operations on that knowledge base.

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

print(f"Name: {kb.name}")
print(f"Vector Store: {kb.vector_store_provider}")
print(f"Embedding: {kb.embedding_model}")
print(f"LLM: {kb.llm_model}")
```

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

### Create a Knowledge Base

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

Initializes a new knowledge base with a specified name and vector store provider. Ensure the vector store is correctly configured.

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

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

### Create and Configure Agent with Features

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

Initialize the Lyzr Studio and create an agent, then add memory and tools to it.

```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)
```

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

### Create and Use a PDF Knowledge Base

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

Demonstrates creating a knowledge base from a PDF document and passing it to an agent at runtime for question answering. Ensure the PDF file exists.

```python
# 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]
)
```

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

### Load API Key from .env File

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

Create a .env file in your project root with your API key. The Studio will automatically load it.

```text
LYZR_API_KEY=your-api-key
```

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

### KnowledgeBase Runtime Configuration (`kb.with_config`)

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

Explains how to create a runtime configuration for custom retrieval settings using `kb.with_config()` and its parameters.

```APIDOC
## kb.with_config()

Create a runtime configuration for custom retrieval settings.

### Parameters

| Parameter           | Type  | Default   | Description                   |
| ------------------- | ----- | --------- | ----------------------------- |
| `top_k`             | int   | 10        | Number of results to retrieve |
| `retrieval_type`    | str   | `"basic"` | Retrieval method              |
| `score_threshold`   | float | 0.0       | Minimum relevance score       |
| `time_decay_factor` | float | 0.4       | Time decay factor             |

### Examples

```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 a Knowledge Base

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

Use `studio.create_knowledge_base()` to create a new knowledge base with specified settings. Ensure your API key is set.

```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}")
```

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

### Initialize Studio Class

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

Instantiate the Studio class, which is the main entry point for interacting with the Lyzr ADK. Provide your API key for authentication.

```python
from lyzr import Studio

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

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

### Define and Use Nested Pydantic Models

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

Defines nested Pydantic models for structured data and uses an agent to generate content conforming to these models. Ensure Pydantic is installed.

```python
from pydantic import BaseModel
from typing import List

class Author(BaseModel):
    name: str
    expertise: str

class Article(BaseModel):
    title: str
    author: Author
    sections: List[str]
    word_count: int

agent = studio.create_agent(
    name="Writer",
    provider="gpt-4o",
    response_model=Article
)

article: Article = agent.run("Write an article about AI")
print(article.author.name)
print(article.sections)
```

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

### Create Agent with Short and Full Provider Formats

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

Initialize an agent using either a short provider name (auto-detected) or a full provider/model path. Ensure your API key is set.

```python
from lyzr import Studio

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

# Short format - auto-resolves provider
agent = studio.create_agent(
    name="Assistant",
    provider="gpt-4o"  # Auto-resolves to OpenAI
)

# Full format - explicit provider
agent = studio.create_agent(
    name="Assistant",
    provider="openai/gpt-4o"
)
```

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

### Select LLM Provider for Agent

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

Demonstrates how to specify different LLM providers when creating an agent. Supported providers include OpenAI, Anthropic, and Google. A full format with a provider prefix is also shown.

```python
# OpenAI
agent = studio.create_agent(provider="gpt-4o", ...)

# Anthropic
agent = studio.create_agent(provider="claude-sonnet-4.5", ...)

# Google
agent = studio.create_agent(provider="gemini-2.5-pro", ...)

# Full format with provider prefix
agent = studio.create_agent(provider="openai/gpt-4o", ...)
```

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

### Create Anthropic Agents

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

Examples for creating agents with Anthropic models, such as Claude Sonnet 4.5 for balanced performance, Claude Opus 4.5 for advanced reasoning, and Claude Haiku for speed.

```python
# Claude Sonnet 4.5 - balanced
agent = studio.create_agent(provider="claude-sonnet-4-5")

# Claude Opus 4.5 - advanced reasoning
agent = studio.create_agent(provider="claude-opus-4-5")

# Claude Haiku - fast
agent = studio.create_agent(provider="claude-3-5-haiku-latest")
```

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

### Create a Basic Agent

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

Instantiate a general-purpose agent with essential parameters like name, provider, role, goal, and instructions.

```python
agent = studio.create_agent(
    name="Assistant",
    provider="gpt-4o",
    role="General assistant",
    goal="Help users with questions",
    instructions="Be helpful and concise"
)
```

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

### Studio Initialization Parameters

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

Initialize the Studio class with an optional API key and logging level. If the API key is not provided, it defaults to the LYZR_API_KEY environment variable.

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

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

### Comparison Search Example

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

Uses the MMR (Maximal Marginal Relevance) retrieval type to find diverse results, useful for comparing different aspects of a topic. The output focuses on distinct pieces of information.

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

# Use MMR for diverse results
results = kb.query(
    "compare product features",
    top_k=5,
    retrieval_type="mmr"
)

# Results will cover different aspects rather than similar content
for result in results:
    print(f"- {result.text[:100]}...")
```

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

### Document Search Example

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

Queries a knowledge base for relevant content on a specific topic. The results include relevance scores, source information, and text snippets. Adjust `top_k` and `score_threshold` for desired results.

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

# Search for relevant content
results = kb.query(
    "authentication flow",
    top_k=10,
    score_threshold=0.5
)

print(f"Found {len(results)} relevant sections:\n")

for i, result in enumerate(results, 1):
    print(f"{i}. [{result.score:.2f}] {result.source}")
    print(f"   {result.text[:150]}...\n")
```

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

### Studio Initialization

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

Initialize the Studio class, the main entry point for the Lyzr ADK. It manages authentication and connections.

```APIDOC
## Studio Initialization

### Description
Initialize the Studio class, the main entry point for the Lyzr ADK. It manages authentication, connections, and provides methods to create and manage all resources.

### Parameters

#### Request Body
- **api_key** (str) - Optional - Lyzr API key. If not provided, reads from `LYZR_API_KEY` environment variable.
- **log** (str) - Optional - Logging level: `"debug"`, `"info"`, `"warning"`, `"error"`, `"none"`. Defaults to `"warning"`.

### Request Example
```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")
```
```
Tokens:
Raw