Building LLM Agents with parlant: A Software Engineer's Guide

emcie-co/parlant

Parlant is useful because it addresses common pain points in developing LLM-powered applications

Real-World Application
It's built for practical use cases, not just theoretical demos. It helps you deploy agents that can take action on your behalf, like managing cloud resources, interacting with APIs, or controlling IoT devices.

Rapid Deployment
The "deployed in minutes" claim is a huge plus. This means you can quickly prototype and test agent-based solutions without a massive time investment.

Control and Safety
The "built for control" part is key. It's not just about giving the LLM free rein; it's about providing a structured, safe environment for the agent to operate within, preventing unintended or dangerous actions. This is crucial for production systems.

Integration with Existing Tech Stacks
The library's focus on Python and its compatibility with major LLM providers (like those mentioned in the project's description) make it easy to integrate into your existing projects. You don't have to start from scratch.

The setup process is pretty straightforward. You'll typically use a package manager like pip to install the library.

Installation

First, open your terminal and install the parlant library. You'll likely need to install it with an extra for the specific LLM provider you plan to use.

pip install parlant[google]  # Or openai, depending on your choice

API Key Setup

Next, you need to set up your API key for the LLM provider. This is how your application authenticates with the AI service. The simplest way is to set it as an environment variable.

export GOOGLE_API_KEY="your_api_key_here"

Writing Your First Agent

Now, you can write some Python code to create a simple agent. The core idea is to define a set of "tools" or "actions" that your agent can use. The agent will then use its language model to decide which tool to use and when, based on the user's request.

Here's a simple example of an agent that can tell you the current time. This illustrates the concept of defining a tool and letting the agent "decide" to use it.

import time
from parlant.agent import Agent, Tool

# Define a tool for getting the current time
def get_current_time():
    """
    Get the current time in a readable format.
    This is a function that our agent can "call".
    """
    return time.strftime("%H:%M:%S", time.localtime())

# Create an agent instance and give it the tool
agent = Agent(
    name="TimeTeller",
    description="An agent that tells you the current time.",
    tools=[
        Tool(
            name="get_time",
            func=get_current_time,
            description="Use this to get the current time."
        )
    ]
)

# Now, we can ask the agent to perform a task
# The agent will analyze the request and decide to use the 'get_time' tool
response = agent.run("What's the time right now?")

print(response)

In this example, the Agent is a class from the parlant library. We create an instance and provide it with a list of Tool objects. Each Tool is a simple wrapper around a Python function (get_current_time in this case). The agent's internal logic, powered by the LLM, will then intelligently choose to call get_current_time when asked about the time.