Lyzr Agent Development Kit

https://pypi.org/project/lyzr-adk
Admin
Lyzr ADK is a production-ready Python SDK for building intelligent AI agents with enterprise...
Tokens:4,723
Snippets:45
Trust Score:10
Update:6 months ago
Show doc for...
Tokens:
Raw
### Setup Development Environment

Source: https://pypi.org/project/lyzr-adk

Commands to clone the repository, install necessary dependencies, and run quickstart examples. Requires an API key to be set in the environment variables.

```bash
# Clone repository
git clone https://github.com/pradipta-lyzr/lyzr-sdk.git
cd lyzr-sdk/python

# Install dependencies
pip install -e ".[dev]"

# Run examples
export LYZR_API_KEY="your-key"
python examples/01_quickstart.py
```

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

### Quick Start Lyzr Agent Example

Source: https://pypi.org/project/lyzr-adk

A quick start guide for creating and interacting with a Lyzr agent. It covers initialization, agent creation, running a query, updating agent configuration, and deleting the agent.

```python
from lyzr import Studio

# Initialize SDK
studio = Studio()

# Create an agent
agent = studio.create_agent(
    name="Assistant",
    provider="openai/gpt-4o",
    role="Helpful assistant",
    goal="Answer questions accurately",
    instructions="Be concise and friendly"
)

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

# Update configuration
agent = agent.update(temperature=0.3)

# Delete when done
agent.delete()

```

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

### Run Example Script

Source: https://pypi.org/project/lyzr-adk

Shows how to execute a Python example script from the `examples/` directory. It requires setting the `LYZR_API_KEY` environment variable before running the script.

```bash
export LYZR_API_KEY="your-api-key"
python examples/01_quickstart.py
```

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

### Install lyzr-adk Python Package

Source: https://pypi.org/project/lyzr-adk

Installs the core lyzr-adk package using pip. This is the standard installation command for most users.

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

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

### Install lyzr-adk for Scheduler Workflows

Source: https://pypi.org/project/lyzr-adk

Installs a lean version of lyzr-adk optimized for scheduler-only workflows. This reduces dependencies for environments where only background task execution is needed.

```bash
pip install lyzr-adk[scheduler]
```

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

### Implement Enterprise Workflow

Source: https://pypi.org/project/lyzr-adk

A complete example integrating knowledge bases, PII redaction policies, structured response models, and custom tools into an agent workflow.

```python
from lyzr import Studio
from lyzr.image_models import Gemini
from lyzr.rai import PIIType, PIIAction
from pydantic import BaseModel

studio = Studio()
kb = studio.create_knowledge_base(name="docs")
kb.add_website("https://docs.company.com")

company = studio.create_context(name="company", value="Tech startup, 50k users")
policy = studio.create_rai_policy(name="Safety", toxicity_threshold=0.3, pii_detection={PIIType.EMAIL: PIIAction.REDACT})

class Report(BaseModel):
    summary: str
    action_items: list[str]
    priority: str

agent = studio.create_agent(
    name="Enterprise Bot",
    provider="openai/gpt-4o",
    role="Business analyst",
    goal="Analyze and report",
    instructions="Provide detailed analysis",
    memory=50,
    contexts=[company],
    rai_policy=policy,
    file_output=True,
    image_model=Gemini.FLASH,
    response_model=Report
)

def analyze_data(data: str) -> str:
    return f"Analysis of: {data}"

agent.add_tool(analyze_data)
response = agent.run("Analyze our documentation and create a report", knowledge_bases=[kb], session_id="session_1")
print(response.summary)
```

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

### Install lyzr-adk for Jupyter/Colab

Source: https://pypi.org/project/lyzr-adk

Installs the lyzr-adk package with extra dependencies for use in Jupyter or Google Colab notebooks. This ensures all notebook-specific functionalities are available.

```bash
pip install lyzr-adk[jupyter]
```

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

### Schedule Agent Tasks

Source: https://pypi.org/project/lyzr-adk

Provides examples for creating, managing, and executing agent tasks using cron expressions in both synchronous and asynchronous modes.

```python
# Create a schedule (every day at 9 AM UTC)
schedule = studio.create_schedule(
    user_id="user_123",
    agent_id="agent_abc",
    cron_expression="0 9 * * *",
    message="Generate daily report"
)

# Async usage
async with Studio() as astudio:
    sched = await astudio.acreate_schedule(
        user_id="user_123",
        agent_id="agent_abc",
        cron_expression="*/15 * * * *",
    )
    await astudio.atrigger_schedule(sched.id)
```

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

### Create and Run a Basic Lyzr Agent

Source: https://pypi.org/project/lyzr-adk

Demonstrates the basic usage of the Lyzr ADK. It initializes the Studio, creates a simple agent, runs a query, and prints the response. Requires the LYZR_API_KEY environment variable to be set.

```python
from lyzr import Studio

studio = Studio()  # Uses LYZR_API_KEY env var agent = studio.create_agent(
    name="Support Bot",
    provider="openai/gpt-4o",
    role="Customer support assistant",
    goal="Help users with technical questions",
    instructions="Be helpful, concise, and professional"
)

response = agent.run("How do I reset my password?")
print(response.response)

```

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

### Initialize Studio Client

Source: https://pypi.org/project/lyzr-adk

Initializes the Studio client, which serves as the main entry point for the Lyzr SDK. Configuration options include API key, environment, request timeout, and logging level.

```python
studio = Studio(
    api_key="sk-xxx",  # Optional, reads from LYZR_API_KEY
    env="prod",        # prod, dev, local
    timeout=30,        # Request timeout in seconds
    log="warning"      # debug, info, warning, error, none
)
```

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

### Create and Run an Agent

Source: https://pypi.org/project/lyzr-adk

Demonstrates the basic lifecycle of an agent, including creation, adding tools and memory, running a message, and deletion. This is a fundamental pattern for interacting with the Lyzr agent.

```python
agent = studio.create_agent(...)
agent.add_tool(my_function)
agent.add_memory(30)
response = agent.run("message")
agent.delete()
```

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

### Configure Logging for Lyzr Studio

Source: https://pypi.org/project/lyzr-adk

Demonstrates how to initialize the Lyzr Studio with different logging levels. Use 'debug' for development to inspect tool execution details and 'warning' or 'error' for production environments.

```python
# Enable debug logging to see internals
studio = Studio(log="debug")

# See tool execution details
agent.run("Use tools")  # Shows tool calls, arguments, results

# Production: use warning/error only
studio = Studio(log="warning")
```

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

### Create and Manage Lyzr Smart Agents

Source: https://pypi.org/project/lyzr-adk

Illustrates the creation, updating, cloning, and deletion of Lyzr agents. It highlights support for multiple providers and models, and configuration options like temperature and top_p.

```python
# Supports 20+ models across 6 providers
agent = studio.create_agent(
    name="Bot",
    provider="openai/gpt-4o",  # or "gpt-4o", "claude-sonnet-4-5", etc.
    role="Assistant",
    goal="Help users",
    instructions="Be helpful",
    temperature=0.7,
    top_p=0.9
)

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

# Update
agent = agent.update(temperature=0.5, instructions="Be very concise")

# Clone
clone = agent.clone("Bot V2")

# Delete
agent.delete()

```

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

### Knowledge Base Configuration

Source: https://pypi.org/project/lyzr-adk

Demonstrates how to apply specific configurations to a Knowledge Base query, such as setting the number of top results, retrieval type, and score threshold.

```python
kb.with_config(top_k=10, retrieval_type="basic", score_threshold=0.0)
```

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

### Manage Knowledge Base Queries and Documents

Source: https://pypi.org/project/lyzr-adk

Demonstrates how to query a knowledge base, configure retrieval parameters, and perform CRUD operations on documents.

```python
# Query directly
results = kb.query("What are the business hours?", top_k=3)
for result in results:
    print(f"{result.score:.2f}: {result.text}")

# Use with agent
response = agent.run(
    "What does the manual say about installation?",
    knowledge_bases=[kb]
)

# Custom retrieval config
response = agent.run(
    "Question?",
    knowledge_bases=[kb.with_config(top_k=5, score_threshold=0.7)]
)

# Manage documents
docs = kb.list_documents()
kb.delete_documents(["doc_123"])
kb.reset()  # Clear all documents
kb.delete()  # Delete KB
```

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

### Configure Studio Environment

Source: https://pypi.org/project/lyzr-adk

Configures the Studio environment for production, development, or local testing, including custom logging levels.

```python
studio = Studio(env="prod")
studio = Studio(env="dev")
studio = Studio(env="local")
studio = Studio(log="debug")
```

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

### Integrate Local Tools

Source: https://pypi.org/project/lyzr-adk

Demonstrates how to extend agent capabilities by adding local Python functions as tools without requiring decorators.

```python
def read_database(query: str) -> dict:
    """Query the database"""
    return {"results": [...]}

# Add tool
agent.add_tool(read_database)

# Single run() works with tools!
response = agent.run("Query the database for recent sales")
```

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

### Knowledge Base Querying and Management

Source: https://pypi.org/project/lyzr-adk

Shows how to query a Knowledge Base, list ingested documents, delete specific documents, reset the KB, update its configuration, and delete the entire KB.

```python
kb.query(query, top_k=5, retrieval_type="basic", score_threshold=0.0)
kb.list_documents()
kb.delete_documents(doc_ids)
kb.reset()
kb.update(**kwargs)
kb.delete()
```

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

### Create and Populate Lyzr Knowledge Base

Source: https://pypi.org/project/lyzr-adk

Demonstrates the creation of a knowledge base for Retrieval-Augmented Generation (RAG) and adding various types of content to it. Supports multiple vector stores and embedding models.

```python
# Create knowledge base
kb = studio.create_knowledge_base(
    name="company_docs",
    vector_store="qdrant",  # qdrant, weaviate, pg_vector, milvus, neptune
    embedding_model="text-embedding-3-large"
)

# Add content
kb.add_pdf("manual.pdf")
kb.add_docx("report.docx")
kb.add_website("https://docs.company.com", max_pages=50)
kb.add_text("FAQ: Our hours are 9-5", source="faq")

```

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

### Manage Agent Context

Source: https://pypi.org/project/lyzr-adk

Explains how to create, update, and attach background information contexts to agents to improve response accuracy.

```python
# Create contexts
company = studio.create_context(
    name="company_info",
    value="Acme Corp - AI solutions provider since 2020"
)

# Add to agent
agent = studio.create_agent(
    name="Support Bot",
    provider="gpt-4o",
    role="Support assistant",
    goal="Help customers",
    instructions="Use context for accurate info",
    contexts=[company]
)
```

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

### Agent Core Methods

Source: https://pypi.org/project/lyzr-adk

Provides an overview of the core methods available for interacting with an agent object, including running messages, updating agent configurations, cloning, and deletion.

```python
# Core methods
agent.run(message, session_id=None, stream=False, **kwargs)
agent.update(**kwargs)
agent.clone(new_name)
agent.delete()
```

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

### Generate Files and Images with Lyzr Agents

Source: https://pypi.org/project/lyzr-adk

Demonstrates how to configure an agent to output files or generate images using specific models. The agent processes tasks and provides artifacts that can be downloaded locally.

```python
# File generation
agent = studio.create_agent(
    name="Report Generator",
    provider="gpt-4o",
    role="Report writer",
    goal="Create detailed reports",
    instructions="Generate comprehensive reports",
    file_output=True
)

response = agent.run("Create a market analysis report")
for artifact in response.artifact_files:
    print(f"File: {artifact.name}")
    artifact.download(f"./downloads/{artifact.name}")

# Image generation
agent = studio.create_agent(
    name="Designer",
    provider="gpt-4o",
    role="Visual designer",
    goal="Create images",
    instructions="Generate creative visuals",
    image_model=Gemini.FLASH
)

response = agent.run("Create a logo for a tech startup")
for img in response.artifact_files:
    img.download(f"./images/{img.name}")
```

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

### Utilize Type Safety and Smart Objects

Source: https://pypi.org/project/lyzr-adk

Demonstrates the use of Enums for type safety and the intuitive API design of Lyzr's smart objects like Knowledge Bases and Contexts.

```python
from lyzr.memory import MemoryProvider
from lyzr.rai import PIIAction

# Type safety
provider = MemoryProvider.MEM0
action = PIIAction.REDACT

# Smart objects
kb = studio.create_knowledge_base(name="docs")
kb.add_pdf("file.pdf")
results = kb.query("question?")
```

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

### Agent Tool Management

Source: https://pypi.org/project/lyzr-adk

Demonstrates how to add local Python functions as tools to an agent, enabling the agent to execute custom logic.

```python
# Tools
agent.add_tool(tool)  # Local function
```

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

### Configure Agent Memory

Source: https://pypi.org/project/lyzr-adk

Shows how to enable conversation context for agents using internal memory or external providers like Mem0 and AWS.

```python
# Agent-level memory (simple)
agent = studio.create_agent(
    name="Bot",
    provider="gpt-4o",
    role="Assistant",
    goal="Help users",
    instructions="Be helpful",
    memory=30  # Keep last 30 messages in context
)

agent.run("My name is Alice", session_id="user_1")
agent.run("What's my name?", session_id="user_1")

# External memory providers
mem0 = studio.create_memory_credential(
    provider="mem0",
    name="Mem0 Memory",
    mem0_api_key="your-key"
)

# AWS AgentCore
aws_memory = studio.create_memory_credential(
    provider="aws-agentcore",
    name="AWS Memory",
    aws_access_key_id="...",
    aws_secret_access_key="...",
    aws_region="us-east-1"
)
```

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

### Implement RAI Guardrails

Source: https://pypi.org/project/lyzr-adk

Configures safety policies for agents, including PII redaction, toxicity thresholds, and topic filtering.

```python
from lyzr.rai import PIIType, PIIAction, SecretsAction

# Create safety policy
policy = studio.create_rai_policy(
    name="SafetyPolicy",
    toxicity_threshold=0.3,
    secrets_detection=SecretsAction.MASK,
    pii_detection={
        PIIType.CREDIT_CARD: PIIAction.BLOCK,
        PIIType.EMAIL: PIIAction.REDACT
    },
    banned_topics=["politics", "religion"]
)

# Add to agent
agent = studio.create_agent(
    name="Safe Bot",
    rai_policy=policy
)
```

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

### Lyzr Agent with Structured Pydantic Outputs

Source: https://pypi.org/project/lyzr-adk

Shows how to use Pydantic models for structured, type-safe responses from Lyzr agents. This enables better code completion and validation.

```python
from pydantic import BaseModel

class Analysis(BaseModel):
    sentiment: str
    score: float
    summary: str

agent = studio.create_agent(
    name="Analyzer",
    provider="gpt-4o",
    role="Sentiment analyzer",
    goal="Analyze text sentiment",
    instructions="Provide detailed analysis",
    response_model=Analysis
)

result: Analysis = agent.run("I love this product!")
print(result.sentiment)  # Type-safe access
print(result.score)      # IDE autocomplete works!

```

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

### Context Object Methods

Source: https://pypi.org/project/lyzr-adk

Details the methods available for a context object, including updating its value, deleting it, and formatting it for feature integration.

```python
context.update(value)
context.delete()
context.to_feature_format()
```

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

### Knowledge Base Document Ingestion

Source: https://pypi.org/project/lyzr-adk

Illustrates methods for adding various document types (PDF, DOCX, TXT, website content, plain text) to a Knowledge Base for RAG capabilities. Parameters like `chunk_size` and `chunk_overlap` can be configured.

```python
kb.add_pdf(file_path, chunk_size=1024, chunk_overlap=128)
b.add_docx(file_path, chunk_size=1024, chunk_overlap=128)
kb.add_txt(file_path, chunk_size=1024, chunk_overlap=128)
kb.add_website(url, max_pages=10, max_depth=2)
kb.add_text(text, source)
```

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

### RAI Policy Object Methods

Source: https://pypi.org/project/lyzr-adk

Describes the methods for managing a RAI Policy object, including updating its configuration, deleting it, and formatting it for endpoint usage.

```python
policy.update(**kwargs)
policy.delete()
policy.to_feature_format(endpoint)
```

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

### Session Management with UUID

Source: https://pypi.org/project/lyzr-adk

Demonstrates how to implement session management using Python's `uuid` module to generate unique session IDs. This is crucial for maintaining conversation context across multiple agent interactions within the same session.

```python
import uuid

# Generate unique session ID per user
session_id = str(uuid.uuid4())

# Maintain conversation context
response1 = agent.run("My name is Bob", session_id=session_id)
response2 = agent.run("What's my name?", session_id=session_id)
```

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

### Agent Context Management

Source: https://pypi.org/project/lyzr-adk

Illustrates how to add and remove context information for an agent, which provides background data for its operations. The `list_contexts` method retrieves the current contexts.

```python
# Context
agent.add_context(context)
agent.remove_context(context)
agent.list_contexts()
```

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

### Agent Image Output Configuration

Source: https://pypi.org/project/lyzr-adk

Covers the configuration of image generation for an agent, including setting the image model and disabling image output. `has_image_output` verifies if image output is enabled.

```python
# Image output
agent.set_image_model(image_model)
agent.disable_image_output()
agent.has_image_output()
```

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

### Memory Provider Object Methods

Source: https://pypi.org/project/lyzr-adk

Outlines the methods for interacting with memory provider credentials, including validation, status checks, resource listing (AWS specific), using existing memory, deleting resources, and deleting the memory object.

```python
memory.validate()
memory.get_status()
memory.list_resources()  # AWS only
memory.use_existing(memory_id)  # AWS only
memory.delete_resource()  # AWS only
memory.delete()
```

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

### Stream Agent Responses

Source: https://pypi.org/project/lyzr-adk

Enables real-time output streaming for agent interactions. Note that streaming is incompatible with RAI guardrails.

```python
for chunk in agent.run("Tell me a story", stream=True):
    print(chunk.content, end="", flush=True)
```

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

### Set Lyzr API Key Environment Variable

Source: https://pypi.org/project/lyzr-adk

Sets the LYZR_API_KEY environment variable. This key is required for authenticating with the Lyzr API when initializing the Studio.

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

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

### Agent RAI Policy Management

Source: https://pypi.org/project/lyzr-adk

Details how to integrate RAI (Responsible AI) policies with an agent to enforce safety and compliance. Methods include adding, removing, and checking for policy presence.

```python
# RAI
agent.add_rai_policy(policy)
agent.remove_rai_policy()
agent.has_rai_policy()
```

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

### Lyzr SDK Error Handling

Source: https://pypi.org/project/lyzr-adk

Provides a robust error handling structure using a try-except block to catch various Lyzr-specific exceptions like `AuthenticationError`, `ValidationError`, `NotFoundError`, `RateLimitError`, and `APIError`. This ensures graceful handling of potential issues during SDK operations.

```python
from lyzr.exceptions import (
    LyzrError,
    AuthenticationError,
    ValidationError,
    NotFoundError,
    APIError,
    RateLimitError,
    TimeoutError
)

try:
    agent = studio.create_agent(...)
    response = agent.run("message")
except AuthenticationError:
    print("Invalid API key")
except ValidationError as e:
    print(f"Invalid input: {e}")
except NotFoundError:
    print("Resource not found")
except RateLimitError:
    print("Rate limit exceeded")
except APIError as e:
    print(f"API error: {e}")
```

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

### Agent File Output Control

Source: https://pypi.org/project/lyzr-adk

Explains how to enable and disable file output capabilities for an agent, allowing it to generate files as part of its responses. `has_file_output` checks the current status.

```python
# File output
agent.enable_file_output()
agent.disable_file_output()
agent.has_file_output()
```

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

### Agent Evaluation Features

Source: https://pypi.org/project/lyzr-adk

Details the various evaluation features that can be enabled or disabled for an agent, such as reflection, bias checks, LLM judging, and groundedness fact management.

```python
# Evaluation features
agent.enable_reflection()
agent.disable_reflection()
agent.enable_bias_check()
agent.disable_bias_check()
agent.enable_llm_judge()
agent.disable_llm_judge()
agent.add_groundedness_facts(["fact1", "fact2"])
agent.remove_groundedness()
```

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

### Agent Memory Management

Source: https://pypi.org/project/lyzr-adk

Shows how to configure and manage conversation memory for an agent, including adding, removing, and checking for memory presence. The `max_messages` parameter controls the conversation history length.

```python
# Memory
agent.add_memory(max_messages=10)
agent.remove_memory()
agent.has_memory()
```
Tokens:
Raw