Parlant

https://www.parlant.io/docs/
Admin
Parlant is an open-source alignment engine for conversational LLM agents that enables developers to...
Tokens:149,239
Snippets:1,599
Trust Score:7.1
Update:1 month ago
Show doc for...
Tokens:
Raw
### Start Parlant Server with Custom NLPService

Source: https://www.parlant.io/docs/advanced/custom-llms

Initialize and start the Parlant server, passing your custom NLP service loader function to the `nlp_service` parameter during server setup.

```python
async with p.Server(
    nlp_service=load_custom_nlp_service,
) as server:
    # Your code here
```

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

### C# HttpClient Example

Source: https://www.parlant.io/docs/api/read-variable

Example of how to use C# HttpClient to make a GET request to retrieve context variable details.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/context-variables/:variable_id");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Retrieve Customer with HttpClient

Source: https://www.parlant.io/docs/api/read-customer

Implementation example using C# HttpClient to perform the GET request.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/customers/:customer_id");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### C# HttpClient Example

Source: https://www.parlant.io/docs/api/read-tag

Example of how to retrieve tag details using HttpClient in C#. This snippet demonstrates making a GET request and handling the response.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/tags/:tag_id");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Guideline Creation Request Example

Source: https://www.parlant.io/docs/api/create-guideline

An example JSON body for creating a new guideline.

```json
{
  "action": "provide current pricing information and mention any ongoing promotions",
  "condition": "when the customer asks about pricing",
  "enabled": true,
  "id": "guid_123xz",
  "metadata": {
    "key1": "value1",
    "key2": "value2"
  },
  "tags": [
    "tag1",
    "tag2"
  ]
}
```

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

### C# HttpClient Request Example

Source: https://www.parlant.io/docs/api/list-customers

Example of how to perform a GET request to the customers endpoint using C# HttpClient.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/customers");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Install Parlant using pip

Source: https://www.parlant.io/docs/quickstart/installation

Install the latest stable version of Parlant from PyPI.

```bash
pip install parlant  

```

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

### Install Parlant Python Client

Source: https://www.parlant.io/docs/quickstart/installation

Use this command to install the Parlant client SDK for Python projects.

```bash
pip install parlant-client  

```

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

### Example Guideline Response

Source: https://www.parlant.io/docs/api/list-guidelines

An example of the JSON structure returned for a list of guidelines.

```json
[
  {
    "action": "provide current pricing information and mention any ongoing promotions",
    "condition": "when the customer asks about pricing",
    "enabled": true,
    "id": "guid_123xz",
    "metadata": {
      "key1": "value1",
      "key2": "value2"
    },
    "tags": [
      "tag1",
      "tag2"
    ]
  }
]
```

```json
[
  {
    "id": "guid_123xz",
    "condition": "when the customer asks about pricing",
    "action": "provide current pricing information and mention any ongoing promotions",
    "enabled": true,
    "tags": [
      "tag1",
      "tag2"
    ],
    "metadata": {
      "key1": "value1",
      "key2": "value2"
    }
  }
]
```

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

### List Services Request with HttpClient

Source: https://www.parlant.io/docs/api/list-services

Example of how to perform a GET request to the services endpoint using C# HttpClient.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/services");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Retrieve Service with HttpClient

Source: https://www.parlant.io/docs/api/read-service

Example of how to perform a GET request to the service endpoint using C# HttpClient.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/services/:name");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Retrieve Agent using HttpClient

Source: https://www.parlant.io/docs/api/read-agent

Example of how to perform the GET request using the C# HttpClient library.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/agents/:agent_id");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Install Parlant MongoDB Extra

Source: https://www.parlant.io/docs/concepts/customization/variables

Install the necessary extra to enable MongoDB as a variable store.

```bash
pip install "parlant[mongo]"
```

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

### Retrieve Guideline using C# HttpClient

Source: https://www.parlant.io/docs/api/read-guideline

Example of how to perform a GET request to retrieve a guideline by its ID using the C# HttpClient.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/guidelines/:guideline_id");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Install Parlant from GitHub (Development Branch)

Source: https://www.parlant.io/docs/quickstart/installation

Install the latest development version from GitHub to access new features.

```bash
pip install git+https://github.com/emcie-co/parlant@develop  

```

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

### HttpClient Request Example

Source: https://www.parlant.io/docs/api/list-capabilities

Example usage of C# HttpClient to retrieve capabilities.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/capabilities");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### C# HttpClient Request Example

Source: https://www.parlant.io/docs/api/list-guidelines

Example implementation using C# HttpClient to call the /guidelines endpoint.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/guidelines");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Journey Details Example

Source: https://www.parlant.io/docs/api/read-journey

An example of a successfully retrieved journey object.

```json
{
  "id": "IUCGT-lvpS",
  "title": "Customer Onboarding",
  "description": "1. Customer wants to lock their card\n2. Customer reports that their card doesn't work\n3. Customer suspects their card has been stolen",
  "conditions": [
    "customer needs unlocking their card",
    "customer needs help with card"
  ],
  "tags": [
    "tag1",
    "tag2"
  ]
}
```

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

### Session Details Response Example (JSON - Alternate Order)

Source: https://www.parlant.io/docs/api/read-session

An alternative example of a successful JSON response with fields in a different order.

```json
{
  "id": "sess_123yz",
  "agent_id": "ag_123xyz",
  "customer_id": "cust_123xy",
  "creation_utc": "2024-03-24T12:00:00Z",
  "title": "Product inquiry session",
  "mode": "auto",
  "consumption_offsets": {
    "client": 42
  },
  "metadata": {
    "simulation": true,
    "priority": "high"
  }
}
```

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

### Session Response Example

Source: https://www.parlant.io/docs/api/create-session

Example of a successful 201 response containing the session details.

```json
{
  "agent_id": "ag_123xyz",
  "consumption_offsets": {
    "client": 42
  },
  "creation_utc": "2024-03-24T12:00:00Z",
  "customer_id": "cust_123xy",
  "id": "sess_123yz",
  "metadata": {
    "priority": "high",
    "simulation": true
  },
  "mode": "auto",
  "title": "Product inquiry session"
}  
```

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

### Capability List Response Example

Source: https://www.parlant.io/docs/api/list-capabilities

An example of a successful 200 OK response containing a list of capability objects.

```json
[
  {
    "description": "Provide a replacement phone when a customer needs repair for their phone.",
    "id": "cap_123abc",
    "signals": [
      "My phone is broken",
      "I need a replacement while my phone is being repaired"
    ],
    "tags": [
      "tag1",
      "tag2"
    ],
    "title": "Provide Replacement Phone"
  }
]
```

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

### List Context Variables Response Example

Source: https://www.parlant.io/docs/api/list-variables

Example JSON response body returned when successfully listing context variables.

```json
[
  {
    "description": "Stores the account balances of users",
    "freshness_rules": "0 8,20 * * *",
    "id": "v9a8r7i6b5",
    "name": "UserBalance",
    "tags": [
      "tag:123",
      "tag:456"
    ],
    "tool_id": {
      "service_name": "finance_service",
      "tool_name": "balance_checker"
    }
  }
]
```

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

### Customer Object Example

Source: https://www.parlant.io/docs/api/read-customer

Example JSON response body for a successful customer retrieval.

```json
{
  "creation_utc": "2024-03-24T12:00:00Z",
  "id": "ck_IdAXUtp",
  "metadata": {
    "VIP": "Yes",
    "email": "scooby@dooby.do"
  },
  "name": "Scooby",
  "tags": [
    "VIP",
    "New User"
  ]
}
```

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

### Install Parlant React Widget

Source: https://www.parlant.io/docs/production/custom-frontend

Install the parlant-chat-react widget using npm or yarn.

```bash
npm install parlant-chat-react  
# or  
yarn add parlant-chat-react  
```

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

### Tag Creation Response Example

Source: https://www.parlant.io/docs/api/create-tag

Example JSON response returned upon successful tag creation.

```json
{
  "creation_utc": "2024-03-24T12:00:00Z",
  "id": "tag_123xyz",
  "name": "premium"
}
```

```json
{
  "id": "tag_123xyz",
  "name": "premium",
  "creation_utc": "2024-03-24T12:00:00Z"
}
```

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

### Guideline JSON Response Example

Source: https://www.parlant.io/docs/api/read-guideline

A complete example of a guideline object, including its associated tools and defined relationships.

```json
{
  "guideline": {
    "action": "provide current pricing information",
    "condition": "when the customer asks about pricing",
    "enabled": true,
    "id": "guid_123xz",
    "tags": [
      "tag1",
      "tag2"
    ]
  },
  "relationships": [
    {
      "id": "123",
      "indirect": false,
      "kind": "entailment",
      "source_guideline": {
        "action": "provide current pricing information",
        "condition": "when the customer asks about pricing",
        "enabled": true,
        "id": "guid_123xz",
        "tags": [
          "tag1",
          "tag2"
        ]
      },
      "target_tag": {
        "id": "tid_456yz",
        "name": "tag1"
      }
    }
  ],
  "tool_associations": [
    {
      "guideline_id": "guid_123xz",
      "id": "gta_101xyz",
      "tool_id": {
        "service_name": "pricing_service",
        "tool_name": "get_prices"
      }
    }
  ]
}
```

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

### Install Parlant TypeScript/JavaScript Client

Source: https://www.parlant.io/docs/quickstart/installation

Use this command to install the Parlant client SDK for TypeScript or JavaScript projects using npm.

```bash
npm install parlant-client  

```

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

### Create a Specific Glossary Term Example

Source: https://www.parlant.io/docs/concepts/customization/glossary

An example of creating a glossary term for a hotel, including its name, description, and various synonyms.

```python
await agent.create_term(  
    name="Boogie Nights",  
    description="Our luxury beachfront hotel located in Miami",  
    synonyms=["BN Hotel", "The Boogie", "Boogie Hotel"],  
)
```

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

### Session Listing Response Example 2

Source: https://www.parlant.io/docs/api/list-sessions

An alternative example JSON response structure for a session list.

```json
{
  "items": [
    {
      "id": "sess_123yz",
      "agent_id": "ag_123xyz",
      "customer_id": "cust_123xy",
      "creation_utc": "2024-03-24T12:00:00Z",
      "title": "Product inquiry session",
      "mode": "auto",
      "consumption_offsets": {
        "client": 42
      },
      "metadata": {
        "simulation": true,
        "priority": "high"
      }
    }
  ],
  "total_count": 1,
  "has_more": false
}
```

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

### Create a Customer

Source: https://www.parlant.io/docs/concepts/entities/customers

Basic example of creating a new customer using the Parlant SDK. Ensure the Server is initialized.

```python
import parlant.sdk as p

async with p.Server() as server:
    customer = await server.create_customer(name="Alice")

```

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

### Install NGINX Ingress Controller for Azure AKS

Source: https://www.parlant.io/docs/production/deployment

Installs the NGINX Ingress Controller using Helm for Azure AKS. This is a simpler option for getting started with ingress on Azure.

```bash
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

helm install nginx-ingress ingress-nginx/ingress-nginx \
  --namespace ingress-nginx \
  --create-namespace \
  --set controller.service.annotations."service.beta.kubernetes.io/azure-load-balancer-health-probe-request-path"=/healthz
```

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

### Create Agent with Custom Preamble Examples

Source: https://www.parlant.io/docs/concepts/entities/agents

Use `p.PreambleConfiguration` with the `examples` field to replace the default preamble set for an agent. This is useful for providing a static list of acknowledgments.

```python
agent = await server.create_agent(  
    name="Hexon",  
    description="Technical support specialist",  
    preamble_config=p.PreambleConfiguration(  
        examples=["One moment, please.", "Let me look into that.", "Checking now."],  
    ),  
)  

```

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

### Configure Parlant Server with OpenAI

Source: https://www.parlant.io/docs/quickstart/installation

Example of initializing the Parlant server to use OpenAI as the NLP service.

```python
async with p.Server(nlp_service=p.NLPServices.openai) as server:  
  ...  

```

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

### Create Agent with Dynamic Preamble Instructions

Source: https://www.parlant.io/docs/concepts/entities/agents

Configure an agent's preamble using `p.PreambleConfiguration` with both `examples` and `get_instructions`. The `get_instructions` callable provides contextual instructions for generating dynamic preambles based on the conversation context.

```python
async def preamble_instruction_provider(ctx: p.EngineContext) -> Sequence[str]:  
    instructions = []  
  
    hour = datetime.now().hour  
    if hour < 12:  
        instructions.append("Use a morning greeting like 'Good morning'")  
    elif hour >= 18:  
        instructions.append("Use an evening greeting like 'Good evening'")  
  
    return instructions  
  
agent = await server.create_agent(  
    name="Hexon",  
    description="Technical support specialist",  
    preamble_config=p.PreambleConfiguration(  
        examples=["One moment, please", "Let me look into that", "Good morning"],  
        get_instructions=preamble_instruction_provider,  
    ),  
)  

```

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

### Create Guideline for Human Handoff

Source: https://www.parlant.io/docs/concepts/sessions

This example demonstrates creating a guideline that triggers a human handoff and assigns the 'human_handoff' label to the session.

```python
await agent.create_guideline(
    condition="The customer is frustrated and wants to speak to a human",
    action="Transfer the conversation to a human agent",
    tools=[human_handoff],
    labels=["human_handoff"],
)
```

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

### Create Guideline: Specific Action and Description

Source: https://www.parlant.io/docs/concepts/customization/guidelines

This snippet demonstrates how to create a guideline with a specific condition, a concise action, and a detailed description. The description provides elaboration on how to execute the action, which is useful for complex scenarios.

```python
await agent.create_guideline(
    condition="The customer mentions a competitor product",
    action="Acknowledge their experience and highlight our differentiators",
    description="Be respectful of competitor products (BrandX, ABC Corp, etc.). "
        "Never disparage them directly. Focus on our key differentiators: "
        "24/7 support, flexible pricing, and satisfaction guarantee.",
)
```

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

### C# HttpClient Request

Source: https://www.parlant.io/docs/api/read-variable-value

Example implementation using C# HttpClient to perform the GET request.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/context-variables/:variable_id/:key");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Initialize Parlant Client and Create Session (Python)

Source: https://www.parlant.io/docs/production/custom-frontend

This Python code demonstrates how to initialize the Parlant client and create a session for an agent and customer. It's the initial setup for interacting with the Parlant service.

```python
from parlant.client import ParlantClient  
  
client = ParlantClient(base_url="http://localhost:8800")  
  
# Create a session tied to your agent  
session = client.sessions.create(  
    agent_id="your-agent-id",  
    customer_id="customer-123",  # optional — omit for guest sessions  
)  
  
# Send a customer message  
client.sessions.create_event(  
    session.id,  
    kind="message",  
    source="customer",  
    message="Hi, I need help with my order",  
)  


```

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

### Define Journey Entry Condition

Source: https://www.parlant.io/docs/engine-internals/journeys

Example of setting a guideline condition that triggers the start of a journey.

```text
condition="Customer wants to book a taxi"  
```

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

### Example Parlant Tool: Fetch Products

Source: https://www.parlant.io/docs/concepts/customization/tools

A concrete example of a tool that fetches products based on a natural-language search query. It simulates fetching data from a database or API.

```python
import parlant.sdk as p

@p.tool
async def find_products(context: p.ToolContext, query: str) -> p.ToolResult:
    """Fetch products based on a natural-language search query."""

    # Simulate fetching the balance from a database or API
    products = await MY_DB.get_products(query=query)

    return p.ToolResult(products)
```

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

### List Relationships with HttpClient

Source: https://www.parlant.io/docs/api/list-relationships

Example of how to perform a GET request to retrieve relationships using C# HttpClient.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/relationships");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Create and Set a Customer Variable

Source: https://www.parlant.io/docs/concepts/customization/variables

Create a 'subscription_plan' variable using the defined tool and set a default value for guest customers.

```python
variable = await agent.create_variable(
    name="subscription_plan",
    description="The customer's subscription plan",
    tool=get_subscription_plan,
)

await variable.set_value_for_customer(
    customer=p.Customer.guest(),
    value="Free Plan",  # Default value for non-registered customers
)
```

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

### C# HttpClient Request

Source: https://www.parlant.io/docs/api/list-terms

Example of how to perform a GET request to the /terms endpoint using C# HttpClient.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/terms");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### C# HttpClient Guideline Creation

Source: https://www.parlant.io/docs/api/create-guideline

Example implementation using C# HttpClient to send a POST request to the guidelines endpoint.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://www.parlant.io/guidelines");
request.Headers.Add("Accept", "application/json");
var content = new StringContent("{\n  \"action\": \"provide current pricing information and mention any ongoing promotions\",\n  \"composition_mode\": \"strict_canned\",\n  \"condition\": \"when the customer asks about pricing\",\n  \"enabled\": false,\n  \"metadata\": {\n    \"key1\": \"value1\",\n    \"key2\": \"value2\"\n  }\n}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### FLUID Mode Example

Source: https://www.parlant.io/docs/engine-internals/message-generation

Demonstrates freeform LLM generation where the agent provides natural, guided responses.

```text
Customer: "What's the best laptop for video editing?"  
  
Agent: "For video editing, I'd recommend looking at laptops with at least  
16GB RAM and a dedicated GPU. Our ProMedia X15 handles 4K footage smoothly  
and is currently 15% off. Would you like me to compare a few options in  
your price range?"  
```

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

### Balanced Guideline for Pricing Inquiries

Source: https://www.parlant.io/docs/production/agentic-design

Implement balanced guidelines that are specific yet flexible. This example shows how to explain pricing tiers, emphasize value, and tailor recommendations.

```python
await agent.create_guideline(  
    condition="Customer asks about pricing",  
    action="Explain our pricing tiers clearly, emphasize value, "  
        "and ask about their specific needs to recommend the best fit"
)
```

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

### C# HttpClient Request

Source: https://www.parlant.io/docs/api/list-canned-responses

Example of how to perform a GET request to the canned responses endpoint using C# HttpClient.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/canned_responses");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Install Prometheus and Grafana for Metrics

Source: https://www.parlant.io/docs/production/deployment

Install Prometheus and Grafana using Helm charts for comprehensive metrics collection and visualization. Ensure the Prometheus community Helm repository is added.

```bash
# Add Prometheus helm repo  
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts  
helm repo update  

# Install Prometheus + Grafana  
helm install prometheus prometheus-community/kube-prometheus-stack \  
  --namespace monitoring \  
  --create-namespace  
```

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

### List Variables Request with HttpClient

Source: https://www.parlant.io/docs/api/list-variables

Example of how to perform a GET request to the /context-variables endpoint using C# HttpClient.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/context-variables");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Read Relationship via C# HttpClient

Source: https://www.parlant.io/docs/api/read-relationship

Example of how to perform a GET request to retrieve a relationship using C# HttpClient.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/relationships/:relationship_id");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### List Events Request with HttpClient

Source: https://www.parlant.io/docs/api/list-events

Example of how to perform a GET request to the list events endpoint using C# HttpClient.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/sessions/:session_id/events");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Run the Parlant server

Source: https://www.parlant.io/docs/quickstart/installation

Execute the main Python script to start the Parlant server.

```bash
python main.py  # Run the server  

```

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

### HttpClient C# implementation for listing tags

Source: https://www.parlant.io/docs/api/list-tags

Example code using C# HttpClient to perform a GET request to the /tags endpoint.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/tags");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Create a Guideline with Action and Description

Source: https://www.parlant.io/docs/concepts/customization/guidelines

This snippet demonstrates how to create a guideline that triggers a specific action when a condition is met. An optional description can provide further context for the action.

```python
await agent.create_guideline(  
    condition="The customer wants to buy a laptop",  
    action="First, determine whether they prefer Mac or Windows",  
    # Optional description for when the action needs more context  
    description="Mac vs. Windows customers tend to have very different profiles "  
        "and are interested in completely different sets of additional products. "  
        "Narrowing this down first helps us understand the customer's profile "  
        "right from the start.",  
)  

```

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

### Create Session using HttpClient

Source: https://www.parlant.io/docs/api/create-session

Example of how to initiate a session request using C# HttpClient.

```csharp
var client = new HttpClient();  
var request = new HttpRequestMessage(HttpMethod.Post, "https://www.parlant.io/sessions");  
request.Headers.Add("Accept", "application/json");  
var content = new StringContent("{\n  \"agent_id\": \"ag_123xyz\",\n  \"customer_id\": \"cust_123xy\",\n  \"metadata\": {\n    \"priority\": \"high\",\n    \"project\": \"demo\"\n  },\n  \"title\": \"Product inquiry session\"\n}", null, "application/json");  
request.Content = content;  
var response = await client.SendAsync(request);  
response.EnsureSuccessStatusCode();  
Console.WriteLine(await response.Content.ReadAsStringAsync());  
```

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

### Retrieve Journeys using C# HttpClient

Source: https://www.parlant.io/docs/api/list-journeys

Example code to perform a GET request to the /journeys endpoint using the C# HttpClient library.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/journeys");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### C# HttpClient Example for Creating Capability

Source: https://www.parlant.io/docs/api/create-capability

This C# code snippet demonstrates how to use HttpClient to send a POST request to create a new capability. It includes setting headers and the request body.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://www.parlant.io/capabilities");
request.Headers.Add("Accept", "application/json");
var content = new StringContent("{\n  \"description\": \"Provide a replacement phone when a customer needs repair for their phone.\",\n  \"id\": \"cap_123abc\",\n  \"signals\": [\n    \"My phone is broken\",\n    \"I need a replacement while my phone is being repaired\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"title\": \"Provide Replacement Phone\"\n}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### C# HttpClient Example

Source: https://www.parlant.io/docs/api/read-term

This C# code snippet demonstrates how to make a GET request to the /terms/:term_id endpoint using HttpClient. Ensure you replace ':term_id' with an actual term ID.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.parlant.io/terms/:term_id");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Example Term Object (JSON - Alternate)

Source: https://www.parlant.io/docs/api/read-term

An alternative example of a term object, demonstrating the same fields as the primary example.

```json
{
  "id": "term-eth01",
  "name": "Gas",
  "description": "A unit in Ethereum that measures the computational effort to execute transactions or smart contracts",
  "synonyms": [
    "Transaction Fee",
    "Blockchain Fuel"
  ],
  "tags": [
    "tag1",
    "tag2"
  ]
}
```

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

### Install AWS Load Balancer Controller

Source: https://www.parlant.io/docs/production/deployment

Installs the AWS Load Balancer Controller using Helm. Ensure you have Helm installed and configured for your EKS cluster.

```bash
# Add the EKS chart repo
helm repo add eks https://aws.github.io/eks-charts
helm repo update

# Install the controller
helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
  -n kube-system \
  --set clusterName=your-cluster-name \
  --set serviceAccount.create=false \
  --set serviceAccount.name=aws-load-balancer-controller
```

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

### Transition to Tool State with Hint

Source: https://www.parlant.io/docs/concepts/customization/journeys

Initiates a transition to a tool state, providing an optional hint on how to use the tool. This can guide the tool's execution when specific instructions are needed.

```python
t = await state.transition_to(tool_state=TOOL, tool_instruction=OPTIONAL_HINT_ON_HOW_TO_USE_TOOL)
```

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

### Example Journey Schema

Source: https://www.parlant.io/docs/api/update-journey

Example of the journey object structure.

```json
{
  "id": "IUCGT-lvpS",
  "title": "Customer Onboarding",
  "description": "1. Customer wants to lock their card\n2. Customer reports that their card doesn't work\n3. Customer suspects their card has been stolen",
  "conditions": [
    "customer needs unlocking their card",
    "customer needs help with card"
  ],
  "tags": [
    "tag1",
    "tag2"
  ]
}
```

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

### Create Capability Request Body Example

Source: https://www.parlant.io/docs/api/create-capability

This example shows the structure of the JSON request body required to create a new capability. Ensure all required fields like title, description, and signals are included.

```json
{
  "description": "Provide a replacement phone when a customer needs repair for their phone.",
  "id": "cap_123abc",
  "signals": [
    "My phone is broken",
    "I need a replacement while my phone is being repaired"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "title": "Provide Replacement Phone"
}
```

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

### C# HttpClient Example for Creating an Agent

Source: https://www.parlant.io/docs/api/create-agent

This C# code snippet demonstrates how to use HttpClient to send a POST request to create a new agent. It includes setting the request headers and content.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://www.parlant.io/agents");
request.Headers.Add("Accept", "application/json");
var content = new StringContent("{\n  \"composition_mode\": \"fluid\",\n  \"description\": \"Technical Support Assistant\",\n  \"max_engine_iterations\": 3,\n  \"name\": \"Haxon\",\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ]\n}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

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

### Event Schema Example

Source: https://www.parlant.io/docs/api/create-event

An example of the JSON structure for an event object.

```json
{
  "creation_utc": "2024-03-24T12:00:00Z",
  "data": {
    "message": "Hello, I need help with my account",
    "participant": {
      "display_name": "John Doe",
      "id": "cust_123xy"
    }
  },
  "id": "evt_123xyz",
  "kind": "message",
  "offset": 0,
  "source": "customer",
  "trace_id": "corr_13xyz"
}
```

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

### Run the Python Script

Source: https://www.parlant.io/docs/quickstart/installation

Execute the Python script to start the Parlant server and agent.

```bash
python main.py
```

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

### Relationship Object Example 1

Source: https://www.parlant.io/docs/api/create-relationship

An example of a relationship object structure.

```json
{
  "id": "123",
  "indirect": false,
  "kind": "entailment",
  "source_guideline": {
    "action": "provide current pricing information",
    "condition": "when the customer asks about pricing",
    "enabled": true,
    "id": "456",
    "tags": [
      "tag1",
      "tag2"
    ]
  },
  "target_tag": {
    "id": "789",
    "name": "tag1"
  }
}
```

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

### Canned Response Example

Source: https://www.parlant.io/docs/api/read-canned-response

A manual example of a successful CannedResponse object retrieval.

```json
{
  "id": "frag123",
  "creation_utc": "2024-03-24T12:00:00Z",
  "value": "Your account balance is {balance}",
  "fields": [
    {
      "name": "balance",
      "description": "Account's balance",
      "examples": [
        9000
      ]
    }
  ],
  "tags": [
    "private",
    "office"
  ],
  "signals": [
    "What is your balance?",
    "How much money do I have?"
  ],
  "metadata": {
    "category": "account",
    "priority": 1
  }
}
```

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

### Integrate Multiple Frameworks with Parlant Agent

Source: https://www.parlant.io/docs/quickstart/framework-integrations

This example demonstrates how to create a Parlant agent that utilizes tools from LangGraph, Claude Agent SDK, Agno, and LlamaIndex for different conversational scenarios. It shows how to define guidelines for specific conditions and attach a retriever for passive grounding.

```python
import parlant.sdk as p
import asyncio

async def main() -> None:
    async with p.Server() as server:
        agent = await server.create_agent(
            name="Support Agent",
            description="A helpful customer support agent.",
        )

        # LangGraph for complex RAG workflows
        await agent.create_guideline(
            condition="The customer asks about company policies or terms",
            action="Search the policy docs and provide an accurate answer",
            tools=[search_company_policies],
        )

        # Claude Agent SDK for deep financial research
        await agent.create_guideline(
            condition="The customer asks about a specific stock or investment opportunity",
            action="Research the stock and present a balanced summary",
            tools=[research_stock],
        )

        # Agno for live web research
        await agent.create_guideline(
            condition="The customer asks to compare products or wants market info",
            action="Research using live web data and present findings",
            tools=[research_product_comparison],
        )

        # LlamaIndex for on-demand knowledge base queries
        await agent.create_guideline(
            condition="The customer asks a product-specific question",
            action="Look up the answer in the knowledge base",
            tools=[query_knowledge_base],
        )

        # LlamaIndex retriever for passive grounding
        await agent.attach_retriever(knowledge_base_retriever)


if __name__ == "__main__":
    asyncio.run(main())
```

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

### Context Variable Example JSON

Source: https://www.parlant.io/docs/api/create-variable

An example of the JSON structure for a context variable.

```json
{
  "description": "Stores the account balances of users",
  "freshness_rules": "0 8,20 * * *",
  "id": "v9a8r7i6b5",
  "name": "UserBalance",
  "tags": [
    "tag:123",
    "tag:456"
  ],
  "tool_id": {
    "service_name": "finance_service",
    "tool_name": "balance_checker"
  }
}
```

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

### Create Guideline and Glossary Terms

Source: https://www.parlant.io/docs/concepts/customization/glossary

This snippet demonstrates creating a guideline that depends on understanding specific glossary terms. It defines a condition for Ocean View rooms and an action related to the Sunrise Package.

```python
await agent.create_guideline(  
    condition="the user asks about Ocean View rooms",  
    action="explain the Sunrise Package benefits",  
)
  
await agent.create_term(  
    name="Ocean View",  
    description="Our premium rooms on floors 15-20 facing the Atlantic",  
    synonyms=["seaside rooms", "beach view"],
)
  
await agent.create_term(  
    name="Sunrise Package",  
    description="Complimentary breakfast and early check-in for Ocean View bookings",  
    synonyms=["morning special", "sunrise special"],
)
```

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

### Create Parlant Server with Custom Authorization

Source: https://www.parlant.io/docs/production/api-hardening

This main function demonstrates how to create a Parlant server instance, integrating the custom authorization policy defined in configure_container.

```python
async def main():  
    # Create Parlant server with custom authorization  
    async with p.Server(  
        configure_container=configure_container,  
    ) as server:  
        # Your agent logic here  
        await server.serve()  
  
if __name__ == "__main__":  
    asyncio.run(main())  

```
Tokens:
Raw