parlant 1.4.2

No project description provided

Parlant: A behavioral control framework for customer-facing LLM agents

Website | Introduction | Installation | Tutorial | About

✨ What is Parlant?

Parlant is a framework that transforms how AI agents make decisions in customer-facing scenarios.

Unlike traditional approaches that rely on prompt engineering or conversational flow charts, Parlant implements a dynamic control system that ensures agents follow your specific business rules by matching and activating the appropriate combination of behavioral guidelines for every specific context.

When an agent needs to respond to a customer, Parlant's engine evaluates the situation, checks relevant guidelines, gathers necessary information through your tools, and continuously re-evaluates its approach based on your guidelines as new information emerges. When it's time to generate a message, Parlant implements self-critique mechanisms to ensure that the agent's responses precisely align with your intended behavior as given by the contextually-matched guidelines.

Parlant comes pre-built with responsive session (conversation) management, a detection mechanism for incoherence and contradictions in guidelines, content-filtering, jailbreak protection, an integrated sandbox UI for behavioral testing, native API clients in Python and TypeScript, and other goodies.

📦 Quickstart

$ pip install parlant
$ parlant-server
$ # Open the sandbox UI at http://localhost:8000 and play

🙋‍♂️🙋‍♀️ Who Is Parlant For?

Parlant is the right tool for the job if you're building an LLM-based chat agent, and:

1. You require a high degree of behavioral precision and consistency, particularly in customer-facing scenarios
2. Your agent is expected to undergo many behavioral refinements and changes, and you need a way to implement those changes efficiently and confidently
3. You're expected to maintain a large set of behavioral guidelines, and you want to maintain them coherently and with version-tracking
4. Conversational UX and user-engagmeent is an important concern for your use case, and you want to easily control the flow and language of conversations

🤔 What Makes Parlant Different?

In a word: guidance. Parlant's engine revolves around solving one key problem: how can we reliably guide customer-facing agents to behave in alignment with our needs and intentions.

Hence Parlant's fundamentally different approach to agent building: Managed Guidelines.

$ parlant guideline create \
    --agent-id MY_AGENT_ID \
    --condition "the customer wants to return an item" \
    --action "get the order number and item name and then help them return it"

By giving structure to behavioral guidelines, and granularizing guidelines (i.e. making each behavioral guideline a first-class entity in the engine), Parlant's engine is able to offer unprecedented control, quality, and efficiency in building LLM-based agents:

1. Reliability: Running focused self-critique in real-time, per guideline, to ensure it is actually followed
2. Explainability: Providing feedback around its interpretation of guidelines in each real-life context, which helps in troubleshooting and improvement
3. Maintainability: Helping you maintain a coherent set of guidelines by detecting and alerting you to possible contradictions (gross or subtle) in your instructions

🚀 Real-world impact

Revenued, a business capital provider, uses Parlant for their Sales Copilot. They leverage Parlant's structured CLI to modify the agent's behavior quickly and easily based on feedback from company stakeholders.

💪 Key benefits

Control that actually works

• Guidelines: Control responses by writing contextual rules - like "offer limited time coupons if it's a holiday" or "make it very clear we don't offer loans if a customer asks about it". By using condition/action definitions, you define exactly when and how your agent should respond
• Glossary: Teach your agent your business-specific terminology so that both you and your customers can speak to it naturally in your language
• Coherence checks: Catch conflicts by having Parlant evaluate new guidelines against existing ones before they're applied
• Dynamic context: Make your agent context-aware by setting user-specific variables like customer account or subscription tier. These shape how your agent responds to each user
• Guided tool use: Control API access by linking tools to specific guidelines. This way, your agent only calls APIs when appropriate and with clear intent

Developer friendly

• See changes instantly: Modify behavior on the fly by updating guidelines directly, no retraining or redeployment needed
• Track changes in Git: Manage agent behavior like code by storing configuration as JSON in your repo. Review, rollback, branch, and merge just like any other code
• Clean architecture: Separate concerns by keeping business logic in tools and conversation patterns in guidelines. Each piece does what it does best
• Type safety: Build rapidly using native TypeScript/JavaScript SDKs with proper type definitions

Deploy with confidence

• Reliable at scale: Parlant filters and selects guidelines per context, allowing you to scale your agent's complexity and use-cases while maintaining consistent, focused behavior
• Debug with ease: Troubleshoot effectively by tracing which guidelines were applied and why for any given response
• Test before deploy: Validate changes using the built-in chat UI to test new behaviors before they reach customers

🤖 Works with all major LLM providers

• OpenAI (also via Azure)
• Gemini
• Meta Llama 3 (via Together AI or Cerebras)
• Anthropic (also via AWS Bedrock)

📚 Learning Parlant

To start learning and building with Parlant, visit our documentation portal.

Need help? Ask us anything on Discord. We're happy to answer questions and help you get up and running!

💻 Usage Example

Adding a guideline for an agent—for example, to ask a counter-question to get more info when a customer asks a question:

parlant guideline create \
    --agent-id CUSTOMER_SUCCESS_AGENT_ID \
    --condition "a free-tier customer is asking how to use our product" \
    --action "first seek to understand what they're trying to achieve"

In Parlant, Customer-Agent interaction happens asynchronously, to enable more natural customer interactions, rather than forcing a strict and unnatural request-reply mode.

Here's a basic example of a simple client (using the TypeScript client SDK):

import { ParlantClient } from 'parlant-client';

const client = ParlantClient({ environment: SERVER_ADDRESS });

session_id = "...";

// Post customer message
const customerEvent = await client.sessions.createEvent(session_id, {
   kind: "message",
   source: "customer",
   message: "How do you use this product?",
});

// Wait for and get the agent's reply
const [agentEvent] = (await client.sessions.listEvents(session_id, {
   kinds: "message",
   source: "ai_agent",
   minOffset: customerEvent.offset,
   waitForData: 60 // Wait up to 60 seconds for an answer
}));

// Print the agent's reply
const { agentMessage } = agentEvent.data as { message: string };
console.log(agentMessage);

// Inspect the details of the message generation process
const { trace } = await client.sessions.inspectEvent(
   session_id,
   agentEvent.id
);

👋 Contributing

We're currently finalizing our contribution guidelines. Check back soon!

Can't wait to get involved? Join us on Discord and let's discuss how you can help shape Parlant. We're excited to work with contributors directly while we set up our formal processes!