emcie-co/parlant | zdoc.app

Le harnais de contrôle des interactions pour les agents IA destinés aux clients

Site Web • Démarrage rapide • Exemples • Discord

Vous cherchez une alternative open-source à Ada, Decagon, ou Sierra ?

Parlant simplifie le développement et la maintenance d'interactions B2C (business-to-consumer) de niveau entreprise et d'interactions B2B sensibles qui doivent être cohérentes, conformes et fidèles à la marque.

Pourquoi Parlant ?

L'ingénierie du contexte conversationnel est difficile car les interactions réelles sont diverses, nuancées et non linéaires.

❌ Le Problème : Ce que vous avez probablement essayé et qui n'a pas fonctionné à grande échelle

Les prompts système fonctionnent jusqu'à ce que la complexité de la production entre en jeu. Plus vous ajoutez d'instructions à un prompt, plus vite votre agent cesse de prêter attention à l'une d'entre elles.

Les graphes routés résolvent le problème de la surcharge des prompts, mais plus vous ajoutez de routage, plus le système devient fragile face au chaos des interactions naturelles.

🔑 La Solution : L'ingénierie du contexte, optimisée pour le contrôle conversationnel

Parlant est un harnais agentique offrant une ingénierie du contexte optimisée pour les cas d'usage conversationnels : obtenir le bon contexte, ni plus ni moins, dans le prompt au bon moment. Vous définissez des règles, des connaissances et des outils une seule fois, tandis que le moteur réduit le contexte en temps réel à ce qui est immédiatement pertinent pour chaque tour de conversation.

Objectifs de conception

Parlant est construit autour de trois objectifs qui façonnent chaque décision dans le framework :

1. Contrôle maximal sur l'expérience conversationnelle

Parlant a été conçu autour d'une idée simple : les développeurs devraient pouvoir contrôler avec précision le comportement de l'agent. Dans les conversations avec les clients, les petits détails comptent, comme le ton, le timing, les cas limites, les contraintes de politique et la voix de la marque. Nous avons donc choisi une conception qui rend ces aspects facilement configurables et gérables. Cette approche ajoute de la complexité, mais elle donne aux équipes un contrôle plus serré sur la façon dont l'agent se comporte dans des conversations réelles.

2. Prévention maximale des comportements indésirables

Parlant traite le désalignement comme un problème de conception fondamental. Il s'appuie sur la recherche sur la précision et la cohérence des modèles afin qu'il soit structurellement plus difficile pour l'agent de se comporter en dehors de ses limites prévues, et plus facile de détecter et de corriger lorsqu'il le fait. Plutôt que de greffer des garde-fous sur la sortie, Parlant applique des contraintes et des points de contrôle dès l'utilisation initiale de vos LLMs pour produire une sortie sûre et correcte.

3. Le chemin le plus rapide du retour produit à l'implémentation

Parlant vise à permettre aux responsables de l'expérience conversationnelle de l'agent de façonner son comportement de manière intuitive, permettant un cycle de feedback rapide que les ingénieurs peuvent intégrer. Parlant est conçu pour vous permettre d'incorporer les retours produits en cours aussi rapidement que possible, sans réécriture manuelle de graphes ou fine-tuning de modèles, garantissant que le temps précieux des ingénieurs n'est nécessaire que pour des changements plus profonds, et non pour des ajustements mineurs.

Pour commencer

pip install parlant

import parlant.sdk as p

async with p.Server():
    agent = await server.create_agent(
        name="Customer Support",
        description="Handles customer inquiries for an airline",
    )

    # Evaluate and call tools only under the right conditions
    expert_customer = await agent.create_observation(
        condition="customer uses financial terminology like DTI or amortization",
        tools=[research_deep_answer],
    )

    # When the expert observation holds, always respond
    # with depth. Set the guideline to automatically match
    # whenever the observation it depends on holds...
    expert_answers = await agent.create_guideline(
        matcher=p.MATCH_ALWAYS,
        action="respond with technical depth",
        dependencies=[expert_customer],
    )

    beginner_answers = await agent.create_guideline(
        condition="customer seems new to the topic",
        action="simplify and use concrete examples",
    )

    # When both match, beginners wins. Neither expert-level
    # tool-data nor instructions can enter the agent's context.
    await beginner_answers.exclude(expert_customer)

Suivez le guide de démarrage rapide en 5 minutes pour une présentation complète.

Parlant en un coup d'œil

Vous définissez le comportement de votre agent en code (pas via des prompts), et le moteur restreint dynamiquement le contexte à chaque tour pour ne conserver que ce qui est immédiatement pertinent, afin que le LLM reste concentré et que votre agent reste aligné.

graph TD
    O[Observations] -->|Events| E[Contextual Matching Engine]
    G[Guidelines] -->|Instructions| E
    J["Journeys (SOPs)"] -->|Current Steps| E
    R[Retrievers] -->|Domain Knowledge| E
    GL[Glossary] -->|Domain Terms| E
    V[Variables] -->|Memories| E
    E -->|Tool Requests| T[Tool Caller]
    T -.->|Results + Optional Extra Matching Iterations| E
    T -->|**Key Result:**<br/>Focused Context Window| M[Message Generation]

Au lieu d'envoyer un long prompt système suivi d'une conversation brute au modèle, Parlant assemble d'abord un contexte ciblé — correspondant uniquement aux instructions et outils pertinents pour chaque tour de conversation — puis génère une réponse à partir de ce contexte restreint.

%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#e8f5e9', 'primaryTextColor': '#1b5e20', 'primaryBorderColor': '#81c784', 'lineColor': '#66bb6a', 'secondaryColor': '#fff9e1', 'tertiaryColor': 'transparent'}}}%%
flowchart LR
    A(User):::outputNode

    subgraph Engine["Parlant Engine"]
        direction LR
        B["Match Guidelines and Resolve Journey States"]:::matchNode
        C["Call Contextually-Associated Tools and Workflows"]:::toolNode
        D["Generated Message"]:::composeNode
        E["Canned Message"]:::cannedNode
    end

    A a@-->|💬 User Input| B
    B b@--> C
    C c@-->|Fluid Output Mode?| D
    C d@-->|Strict Output Mode?| E
    D e@-->|💬 Fluid Output| A
    E f@-->|💬 Canned Output| A

    a@{animate: true}
    b@{animate: true}
    c@{animate: true}
    d@{animate: true}
    e@{animate: true}
    f@{animate: true}

    linkStyle 2 stroke-width:2px
    linkStyle 4 stroke-width:2px
    linkStyle 3 stroke-width:2px,stroke:#3949AB
    linkStyle 5 stroke-width:2px,stroke:#3949AB

    classDef composeNode fill:#F9E9CB,stroke:#AB8139,stroke-width:2px,color:#7E5E1A,stroke-width:0
    classDef cannedNode fill:#DFE3F9,stroke:#3949AB,stroke-width:2px,color:#1a237e,stroke-width:0

De cette manière, ajouter plus de règles rend l'agent plus intelligent, pas plus confus — parce que le moteur filtre la pertinence du contexte, pas le LLM.

Parlant est-il fait pour vous ?

Parlant est conçu pour les équipes qui ont besoin que leur agent IA se comporte de manière fiable face à de vrais clients. C'est une bonne solution si :

Vous construisez un agent destiné aux clients — support, vente, intégration, conseil — où le ton, la précision et la conformité sont importants.
Vous avez des dizaines ou des centaines de règles comportementales et votre prompt système ploie sous le poids.
Vous évoluez dans un domaine réglementé ou à enjeux élevés (finance, assurance, santé, télécom) où chaque réponse doit être explicable et vérifiable.

Parlant est déployé en production dans les organisations les plus exigeantes, y compris des banques.

Parlant n'est pas seulement un framework. C'est un logiciel de haut niveau qui résout de front le problème de la modélisation conversationnelle. — Sarthak Dalabehera, Ingénieur Principal, Slice Bank

De loin le framework d'IA conversationnelle le plus élégant que j'aie rencontré. — Vishal Ahuja, Senior Lead, Applied AI, JPMorgan Chase

Parlant réduit considérablement le besoin en prompt engineering et en contrôle de flux complexe. La construction d'agents se rapproche davantage de la modélisation de domaine. — Diogo Santiago, AI Engineer, Oracle

Fonctionnalités

Guidelines — Règles comportementales sous forme de paires condition-action ; le moteur ne correspond qu'à ce qui est pertinent à chaque tour.
Relationships — Dépendances et exclusions entre les guidelines pour maintenir le contexte étroit et ciblé.
Journeys — SOPs multi-tours qui s'adaptent à la manière dont le client interagit réellement.
Canned Responses — Modèles de réponse pré-approuvés qui éliminent les hallucinations aux moments critiques.
Tools — APIs externes et workflows, déclenchés uniquement lorsque leur observation correspond.
Glossary — Vocabulaire spécifique au domaine pour que l'agent comprenne le langage du client.
Explainability — Traçabilité OpenTelemetry complète — chaque correspondance de guideline et décision est enregistrée.

Guidelines

Règles comportementales sous forme de paires condition-action : lorsque la condition s'applique, l'action entre en vigueur dans le contexte.

Au lieu d'entasser toutes les directives dans un seul prompt, le moteur évalue celles qui s'appliquent à chaque tour de conversation et n'inclut que les pertinentes dans le contexte du LLM.

Cela vous permet de définir des centaines de directives sans dégrader leur respect.

await agent.create_guideline(
    condition="customer uses financial terminology like DTI or amortization",
    action="respond with technical depth — skip basic explanations",
)

Relationships

Les relations entre les éléments vous aident à maintenir le contexte final juste comme il faut : étroit et ciblé.

Les relations d'Exclusion empêchent certaines directives d'être prises en compte par le modèle lorsque des directives conflictuelles sont activées.

for_experts = await agent.create_guideline(
    condition="customer uses financial terminology",
    action="respond with technical depth",
)

for_beginners = await agent.create_guideline(
    condition="customer seems new to the topic",
    action="simplify and use concrete examples",
)

# In conflicting reads of the customer, set which takes priority
await for_beginners.exclude(for_experts)

Les relations de Dépendance garantissent qu'une directive ne s'active que lorsqu'une autre a préparé le terrain, vous aidant ainsi à créer des hiérarchies de directives basées sur des sujets.

suspects_fraud = await agent.create_observation(
    condition="customer suspects unauthorized transactions on their card",
)

await agent.create_guideline(
    condition="customer wants to take action regarding the transaction",
    action="ask whether they want to dispute the transaction or lock the card",
    # Only activates when fraud suspicion has been established
    dependencies=[suspects_fraud],
)

Journeys

Procédures opérationnelles standard (SOP) multi-tours. Définissez un flux pour des processus comme la réservation, le dépannage ou l'intégration. L'agent suit le flux mais s'adapte — il peut avancer rapidement dans les états, revenir à des étapes antérieures ou ajuster le rythme en fonction de l'interaction avec le client.

journey = await agent.create_journey(
    title="Book Flight",
    description="Guide the customer through flight booking",
    conditions=["customer wants to book a flight"],
)

t0 = await journey.initial_state.transition_to(
    # Instruction to follow while in this state (could be multiple turns)
    chat_state="See if they're interested in last-minute deals",
)

# Branch A - not interested in deals
t1 = await t0.target.transition_to(
    chat_state="Determine where they want to go and when",
    condition="They aren't interested",
)

# Branch B - interested in deals
t2 = await t0.target.transition_to(
    tool_state=load_latest_flight_deals,
    condition="They are",
)

t3 = await t1.target.transition_to(
    chat_state="List deals and see if they're interested",
)

Canned Responses

Aux moments critiques ou lors d'événements conversationnels, limitez l'agent à utiliser uniquement des modèles de réponse pré-approuvés.

Après avoir exécuté la séquence de correspondance et rédigé un message pour le client, l'agent sélectionne le modèle qui correspond le mieux à son projet de message généré au lieu de l'envoyer directement, éliminant ainsi tout risque d'hallucination et conservant une formulation exacte au mot près.

await agent.create_guideline(
    condition="The customer discusses things unrelated to our business"
    action="Tell them you can't help with that",
    # Strict composition mode triggers when this guideline
    # matches - the rest of the agent stays fluid
    composition_mode=p.CompositionMode.STRICT,
    canned_responses=[
        await agent.create_canned_response(
            "Sorry, but I can't help you with that."
        )
    ],
    priority=100,  # Top priority, focuses the agent on this alone
)

Outils

Les outils ne s'activent que lorsque leur observation correspond ; ils ne restent pas en permanence dans le contexte. Cela empêche les invocations faussement positives qui affectent les configurations d'outils LLM traditionnelles.

@p.tool
async def query_docs(context: p.ToolContext, user_query: str) -> p.ToolResult:
    results = search_knowledge_base(user_query)
    return p.ToolResult(results)

await agent.create_observation(
    condition="customer asks about service features",
    tools=[query_docs],
)

Les outils peuvent également alimenter des valeurs personnalisées dans les modèles de réponse prédéfinis.

Glossaire

Vocabulaire spécifique au domaine pour votre agent. Mappez les termes familiers et les synonymes vers des définitions métier précises afin que l'agent comprenne le langage du client.

await agent.create_term(
    name="Ocean View",
    description="Room category with direct view of the Atlantic",
    synonyms=["sea view", "rooms with a view to the Atlantic"],
)

Explicabilité

Chaque décision est tracée avec OpenTelemetry. Parlant est livré prêt à l'emploi avec des journaux, des métriques et des traces élaborés.

Intégration du Framework

Parlant gère la gouvernance conversationnelle ; il ne remplace pas votre pile existante.

Utilisez-le aux côtés de frameworks comme LangGraph, Agno, LlamaIndex, ou d'autres pour l'automatisation des flux de travail et la recherche de connaissances. Parlant prend en charge la couche de contrôle comportemental tandis que le framework de votre choix gère le reste de la logique de traitement de votre agent.

Tout flux de travail ou agent externe devient un outil Parlant, déclenché uniquement lorsqu'il est pertinent :

from my_workflows import refund_graph  # a compiled LangGraph StateGraph

@p.tool
async def run_refund_workflow(
  context: p.ToolContext,
  order_id: str
) -> p.ToolResult:
    result = await refund_graph.ainvoke({"order_id": order_id})

    # Graph result can inject both data and instructions into the agent.
    # Instructions are transformed to guidelines, and participate
    # in contextual guideline resolution (including prioritizations)

    return p.ToolResult(
        data=result["data"],
        # Inject dynamic guidelines from workflow result
        guidelines=[
            {"action": inst, "priority": 3} for inst in result["instructions"]
        ],
    )

await agent.create_observation(
    condition="customer wants to process a refund",
    tools=[run_refund_workflow],
)

Le même schéma fonctionne avec les moteurs de requête LlamaIndex, les agents Agno, ou toute fonction Python asynchrone.

Indépendant du LLM

Parlant fonctionne avec la plupart des fournisseurs de LLM. Les recommandés sont Emcie qui offre un excellent rapport coût/qualité car il est conçu spécifiquement pour Parlant, mais OpenAI et Anthropic produisent également des résultats de qualité exceptionnelle. Vous pouvez aussi utiliser n'importe quel modèle et fournisseur via LiteLLM, mais ils doivent être de bonne qualité - les modèles standards trop petits ont tendance à produire des résultats incohérents.

Généralement, vous pouvez changer de modèle sans modifier la configuration comportementale.

Widget de chat React officiel

Composant de chat prêt à l'emploi pour obtenir une interface frontend immédiatement.

En savoir plus

Comment Parlant garantit la conformité — plongée au cœur du moteur
Parlant vs LangGraph — quand utiliser l'un ou l'autre
Parlant vs DSPy — des outils différents pour des problèmes différents

Communauté

Discord — posez des questions, partagez vos créations
GitHub Issues — rapports de bugs et demandes de fonctionnalités
Contact — contactez directement l'équipe d'ingénierie

Si Parlant vous aide à construire de meilleurs agents, donnez-lui une étoile — cela aide d'autres personnes à découvrir le projet.

Licence

Apache 2.0 — libre d'utilisation commerciale.

Essayez-le maintenant • Rejoindre Discord • Lire la documentation

Développé par l'équipe de Emcie