Parlant is a framework designed to assist builders construct production-ready AI brokers that behave constantly and reliably. A standard problem when deploying massive language mannequin (LLM) brokers is that they typically carry out nicely in testing however fail when interacting with actual customers. They might ignore rigorously designed system prompts, generate inaccurate or irrelevant responses at vital moments, battle with edge instances, or produce inconsistent habits from one dialog to a different.
Parlant addresses these challenges by shifting the main focus from immediate engineering to principle-driven improvement. As an alternative of counting on prompts alone, it supplies mechanisms to outline clear guidelines and gear integrations, making certain that an agent can entry and course of real-world information safely and predictably.
On this tutorial, we’ll create an insurance coverage agent that may retrieve open claims, file new claims, and supply detailed coverage info, demonstrating tips on how to combine domain-specific instruments right into a Parlant-powered AI system for constant and dependable buyer assist. Take a look at the FULL CODES right here.
Putting in & importing the dependencies
import asyncio
from datetime import datetime
import parlant.sdk as pDefining the instruments
The next code block introduces three instruments that simulate interactions an insurance coverage assistant would possibly want.
- The get_open_claims instrument represents an asynchronous operate that retrieves a listing of open insurance coverage claims, permitting the agent to offer customers with up-to-date details about pending or authorized claims.
- The file_claim instrument accepts declare particulars as enter and simulates the method of submitting a brand new insurance coverage declare, returning a affirmation message to the consumer.
Lastly, the get_policy_details instrument supplies important coverage info, such because the coverage quantity and protection limits, enabling the agent to reply precisely to questions on insurance coverage protection. Take a look at the FULL CODES right here.
@p.instrument
async def get_open_claims(context: p.ToolContext) -> p.ToolResult:
return p.ToolResult(information=["Claim #123 - Pending", "Claim #456 - Approved"])
@p.instrument
async def file_claim(context: p.ToolContext, claim_details: str) -> p.ToolResult:
return p.ToolResult(information=f"New declare filed: {claim_details}")
@p.instrument
async def get_policy_details(context: p.ToolContext) -> p.ToolResult:
return p.ToolResult(information={
"policy_number": "POL-7788",
"protection": "Covers unintended injury and theft as much as $50,000"
})Defining Glossary & Journeys
On this part, we outline the glossary and journeys that form how the agent handles area information and conversations. The glossary incorporates essential enterprise phrases, such because the customer support quantity and working hours, permitting the agent to reference them precisely when wanted.
The journeys describe step-by-step processes for particular duties. On this instance, one journey walks a buyer by submitting a brand new insurance coverage declare, whereas one other focuses on retrieving and explaining coverage protection particulars. Take a look at the FULL CODES right here.
async def add_domain_glossary(agent: p.Agent):
await agent.create_term(
identify="Buyer Service Quantity",
description="You possibly can attain us at +1-555-INSURE",
)
await agent.create_term(
identify="Working Hours",
description="We can be found Mon-Fri, 9AM-6PM",
)
async def create_claim_journey(agent: p.Agent) -> p.Journey:
journey = await agent.create_journey(
title="File an Insurance coverage Declare",
description="Helps clients report and submit a brand new declare.",
situations=["The customer wants to file a claim"],
)
s0 = await journey.initial_state.transition_to(chat_state="Ask for accident particulars")
s1 = await s0.goal.transition_to(tool_state=file_claim, situation="Buyer supplies particulars")
s2 = await s1.goal.transition_to(chat_state="Affirm declare was submitted")
await s2.goal.transition_to(state=p.END_JOURNEY)
return journey
async def create_policy_journey(agent: p.Agent) -> p.Journey:
journey = await agent.create_journey(
title="Clarify Coverage Protection",
description="Retrieves and explains buyer's insurance coverage protection.",
situations=["The customer asks about their policy"],
)
s0 = await journey.initial_state.transition_to(tool_state=get_policy_details)
await s0.goal.transition_to(
chat_state="Clarify the coverage protection clearly",
situation="Coverage data is out there",
)
await agent.create_guideline(
situation="Buyer presses for authorized interpretation of protection",
motion="Politely clarify that authorized recommendation can't be supplied",
)
return journeyThe principle runner ties collectively all of the parts outlined in earlier cells and launches the agent. It begins a Parlant server, creates the insurance coverage assist agent, and masses its glossary, journeys, and world pointers. It additionally handles edge instances akin to ambiguous buyer intent by prompting the agent to decide on between related journeys. Lastly, as soon as the script is executed, the server turns into lively and prints a affirmation message. You possibly can then open your browser and navigate to http://localhost:8800 to entry the Parlant UI and start interacting with the insurance coverage agent in actual time. Take a look at the FULL CODES right here.
async def important():
async with p.Server() as server:
agent = await server.create_agent(
identify="Insurance coverage Help Agent",
description="Pleasant {and professional}; helps with claims and coverage queries.",
)
await add_domain_glossary(agent)
claim_journey = await create_claim_journey(agent)
policy_journey = await create_policy_journey(agent)
# Disambiguation: if intent is unclear
status_obs = await agent.create_observation(
"Buyer mentions a problem however would not specify if it is a declare or coverage"
)
await status_obs.disambiguate([claim_journey, policy_journey])
# World guideline
await agent.create_guideline(
situation="Buyer asks about unrelated matters",
motion="Kindly redirect them to insurance-related assist solely",
)
print("✅ Insurance coverage Agent is prepared! Open the Parlant UI to speak.")
if __name__ == "__main__":
import asyncio
asyncio.run(important())
Take a look at the FULL CODES right here. Be at liberty to take a look at our GitHub Web page for Tutorials, Codes and Notebooks. Additionally, be happy to comply with us on Twitter and don’t overlook to hitch our 100k+ ML SubReddit and Subscribe to our E-newsletter.
For content material partnership with marktechpost.com, please TALK to us
I’m a Civil Engineering Graduate (2022) from Jamia Millia Islamia, New Delhi, and I’ve a eager curiosity in Knowledge Science, particularly Neural Networks and their software in varied areas.
