# Documentation pour développeurs

> Créez une compétence vocale, ou connectez votre application à un hub Thalovant avec un SDK.

Source: https://docs.thalovant.com/fr/developers/

---
{/* Last Edit: Claude Opus 5.5 - 2026-09-28 - Motive: Canadian French translation of developers/index.mdx; terms per docs/french-glossary.md (AMF, serveur), and review fixes. */}

Vous pouvez bâtir deux choses ici, et ce sont deux métiers différents.

Une **compétence** tourne sur le hub et répond à un type de demande précis : c'est le code
derrière « quel temps fait-il? ». Un **SDK** est une bibliothèque que votre propre
application utilise pour envoyer des demandes à un hub et lire les réponses.

  
  

## Votre première requête :badge[Nouveau]{variant=tip}

Choisissez l'onglet de votre langage. Chaque SDK fait les quatre mêmes choses :
se connecter, créer une identité de client sur un hub, ouvrir une connexion WSS,
demander. Le texte de la réponse est ce que le hub aurait dit à voix haute.

  
    ```python
    from thalovant import ThalovantClient, ThalovantControlPlane

    api = ThalovantControlPlane()

    hub = api.list_public_hubs(limit=1)["data"][0]
    print(hub["title"], hub["slug"])

    api.login("you@example.com", "password")

    result = api.create_client_identity(
        hub["id"],
        name="python-demo-client",
        preferred_protocols=("wss", "https", "mqtt"),
    )

    with ThalovantClient(result.identity, protocol="wss") as client:
        reply = client.ask("Tell me a short clean joke.")
        print(reply.text)
    ```
  
  
    ```ts
    import { ThalovantClient, ThalovantControlPlane } from "@thalovant/sdk";

    const api = new ThalovantControlPlane();

    const publicHubs = await api.listPublicHubs({ limit: 1 });
    const [hub] = publicHubs.data as Array<{ id: string; slug: string; title: string }>;
    console.log(hub.title, hub.slug);

    await api.login("you@example.com", "password");

    const result = await api.createClientIdentity(hub.id, {
      name: "node-demo-client",
      preferredProtocols: ["wss", "https", "mqtt"],
    });

    const client = new ThalovantClient(result.identity, { protocol: "wss" });
    try {
      const reply = await client.ask("Tell me a short clean joke.");
      console.log(reply.text);
    } finally {
      await client.close();
    }
    ```
  
  
    ```go
    package main

    import (
    	"context"
    	"fmt"
    	"log"

    	thalovant "github.com/thalovant/thalovant-go-sdk"
    )

    func main() {
    	ctx := context.Background()
    	control := thalovant.NewDefaultControlPlane("")

    	_, err := control.Login(ctx, "you@example.com", "password", "")
    	if err != nil {
    		log.Fatal(err)
    	}

    	result, err := control.CreateClientIdentityForHubID(ctx, "hub-id", thalovant.BootstrapIdentityOptions{
    		Name: "go-demo-client",
    		PreferredProtocols: []thalovant.HubProtocol{
    			thalovant.ProtocolWSS,
    			thalovant.ProtocolHTTPS,
    			thalovant.ProtocolMQTT,
    		},
    	})
    	if err != nil {
    		log.Fatal(err)
    	}

    	client, err := thalovant.NewClientWithOptions(result.Identity, thalovant.ClientOptions{
    		Protocol: thalovant.ProtocolWSS,
    	})
    	if err != nil {
    		log.Fatal(err)
    	}
    	defer client.Close(ctx)

    	reply, err := client.Ask(ctx, "Tell me a short clean joke.", thalovant.RequestOptions{})
    	if err != nil {
    		log.Fatal(err)
    	}

    	fmt.Println(reply.Text)
    }
    ```
  
  
    ```rust
    use thalovant::{
        BootstrapIdentityOptions, Client, ControlPlane, HubProtocol, RequestOptions,
    };

    #[tokio::main]
    async fn main() -> thalovant::Result<()> {
        let mut control = ControlPlane::default();

        control.login("you@example.com", "password", None).await?;

        let result = control
            .create_client_identity_for_hub_id(
                "hub-id",
                BootstrapIdentityOptions {
                    name: "rust-demo-client".into(),
                    preferred_protocols: vec![HubProtocol::Wss, HubProtocol::Https, HubProtocol::Mqtt],
                    ..Default::default()
                },
            )
            .await?;

        let client = Client::with_protocol(result.identity.clone(), HubProtocol::Wss)?;
        let reply = client
            .ask("Tell me a short clean joke.", RequestOptions::default())
            .await;
        let closed = client.close().await;
        let reply = reply?;
        closed?;
        println!("{}", reply.text);

        Ok(())
    }
    ```
  
  
    ```kotlin
    import com.thalovant.sdk.CreateClientIdentityOptions
    import com.thalovant.sdk.ThalovantClient
    import com.thalovant.sdk.ThalovantControlPlane
    import kotlinx.coroutines.runBlocking

    fun main() = runBlocking {
        val api = ThalovantControlPlane()

        api.login("you@example.com", "password")

        val result = api.createClientIdentity(
            "hub-id",
            CreateClientIdentityOptions(name = "kotlin-demo-client"),
        )

        val client = ThalovantClient(result.identity)
        try {
            val reply = client.ask("Tell me a short clean joke.")
            println(reply.text)
        } finally {
            client.close()
        }
    }
    ```
  
  
    ```swift
    import ThalovantSDK

    let api = ThalovantControlPlane()

    try await api.login(email: "you@example.com", password: "password")

    let result = try await api.createClientIdentity(
        hubId: "hub-id",
        options: CreateClientIdentityOptions(name: "swift-demo-client")
    )

    let client = try ThalovantClient(identity: result.identity)
    do {
        try await client.connect()
        let reply = try await client.ask("Tell me a short clean joke.")
        print(reply.text)
        await client.close()
    } catch {
        await client.close()
        throw error
    }
    ```
  
  
    ```csharp
    using Thalovant;

    var api = new ThalovantControlPlane();

    await api.LoginAsync("you@example.com", "password");

    var result = await api.CreateClientIdentityAsync(
        "hub-id",
        new CreateClientIdentityOptions("dotnet-demo-client"));

    using var client = new ThalovantClient(result.Identity);
    await client.ConnectAsync();
    var reply = await client.AskAsync("Tell me a short clean joke.");
    Console.WriteLine(reply.Text);
    await client.CloseAsync();
    ```
  

Chaque page de SDK explique les morceaux : où l'identité est conservée, quels
protocoles le hub accepte, quoi passer comme contexte et comment écouter les
événements.

## Créer une compétence

Commencez par le [tutoriel Pocket Quiz](/fr/developers/skillkit-tutorial/). Vous pouvez
tout écrire et tout tester sur votre ordinateur avant même d'avoir un hub.
Il explique à quoi sert chaque fichier et vous dit ce que vous devriez voir
après chaque étape.

Quand ses vérifications passent, [Ajouter votre propre compétence](/fr/manage/add-your-own-skill/)
l'installe sur un hub de test. Posez-lui ensuite une question à voix haute, essayez
une question de suivi et vérifiez que « stop » met fin à la partie.

[Écrire une compétence](/fr/developers/writing-a-skill/) est la référence que vous ouvrirez
ensuite : fonctions utilitaires, règles de conversation, tests, empaquetage.
[Garder votre compétence réactive](/fr/developers/skillkit-runtime/) traite de la mise en cache,
des appels de service bornés et du rafraîchissement en arrière-plan.

## Connecter votre application

Thalovant crée l'identité du client et sa règle d'accès; votre SDK utilise cette
identité pour se connecter directement au hub.

1. **Choisissez un hub.** Un hub public est ce qu'il y a de plus simple pour tester.
2. **Créez une identité de client.** Il faut pour cela un accès à l'API dans l'espace de travail.
3. **Installez un SDK.** Prenez le langage dans lequel votre application est déjà écrite.
4. **Connectez-vous en WSS.** C'est le transport par défaut, et tous les SDK le prennent en charge.
5. **N'ajoutez HTTPS ou MQTT que si vous en avez besoin.** Python, Node.js, Go et Rust
   prennent en charge les deux une fois que le hub les active. Kotlin, Swift et .NET ne font que du WSS;
   le C embarqué utilise le transport que votre micrologiciel a déjà.
6. **Demandez une origine SDK si vous êtes dans un navigateur.** Un domaine qui vous appartient
   doit être approuvé avant que les appels d'une origine à une autre soient acceptés.
7. **Ajoutez le contexte en dernier.** Les métadonnées d'utilisateur, d'appareil, de session et de trace
   valent la peine une fois que la première requête simple fonctionne.

  
  
  
  
  
  
  
  

## À propos de l'API REST

Tout ici passe par un SDK, et c'est voulu. Les SDK sont la surface prise en
charge : ils s'occupent de la session chiffrée et authentifiée, des clés enregistrées
dont une reconnexion a besoin, de la corrélation des requêtes, et des nouvelles tentatives
et annulations qu'un client HTTP fait maison doit réussir tout seul.

Il n'y a pas de référence REST publiée. Si vous en cherchez une, voilà pourquoi :
ce n'est pas un oubli. Prenez le SDK le plus proche de votre langage, même le
[C embarqué](/fr/developers/sdks/embedded-c/), qui apporte son propre transport et
vous laisse les sockets.

## Connecter un agent

Le [serveur MCP](/fr/developers/mcp/) expose les hubs à Claude, Codex, Cursor et
d'autres agents sous forme d'outils. Un agent peut ainsi poser une question à un hub ou gérer des compétences
sans que vous ayez à écrire de client.

## Tout le reste