# Welcome to Thalovant

> Build assistants, agents, and apps with Thalovant hubs, skills, SDKs, MCP, and connected devices. Explore public hubs or manage a private workspace.

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

---
Thalovant hubs run skills and return text, speech, or structured output to
connected clients. Voice is one way in; your client can also be an app, an
agent, a service, or a device. Try a public hub, then use a private workspace
for your own skills, clients, and access rules.

## Two Ways In

  
    Try an assistant in your browser or connect your phone, speaker, or
    computer. Start with [what Thalovant is](/start/what-is-thalovant/) if the
    word "hub" is new to you, then follow the [voice setup
    guide](/start/first-successful-setup/) when you want spoken replies.
  
  
    Teach a hub something new with a skill, or talk to one from your own code:
    Python, Node.js, Go, Rust, Kotlin, Swift, .NET or C. Connect agents through
    [MCP](/developers/mcp/), and use [MQTT](/developers/mqtt/) where your hub
    and SDK support it. The [developer pages](/developers/) start with a first request.
  

## Try It Before Anything Else

You don't need an account, an app, or a hub of your own to try it.
[Open a public hub in your browser](https://dash.thalovant.com/explore), pick
one of its starter questions, and read the answer. That takes about thirty
seconds and costs nothing.

Everything below is for when you want it in a room, on a phone, or in your own
code.

Before choosing a device, see [what runs locally and what needs a hosted
hub](/start/hosted-and-local/). Local voice features do not make the whole
assistant an offline service.

## The Whole Thing in Five Minutes

For the voice setup path, the first goal is a spoken reply. Apps and agents
can start with a [request from code](/developers/) instead.

1. **Pick a hub.** The hub is the brain: it listens, understands, and answers.
   Start with a public one; make your own later.
2. **Connect a client.** The client is the phone, speaker, or app that carries your voice to the hub.
3. **Say the wake word, then ask.** "Hey Jarvis — what time is it?"
4. **Hear it answer.** That's the finish line. Everything before it is setup.

If you get an answer out loud, your setup works. If you don't,
[start from what you can see](/troubleshooting/symptom-index/) — that page begins
with symptoms, not causes.

[**Set it up →**](/start/first-successful-setup/)

## Three Words You Will Keep Meeting

| Word | What it means |
| --- | --- |
| **Hub** | Runs skills to handle requests and return responses. One hub can serve many clients. |
| **Client** | Connects to a hub to send requests and receive responses: a phone, a speaker, an app, a script, an agent. |
| **Access rules** | What a client is allowed to do on its hub. Narrow is better. |

Nothing else is required to finish the first setup.

## If You Write Code

The same first request in three of the eight SDKs. Each one signs in, creates
a client identity on a public hub, connects over WSS and asks one question.

  
    ```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();
    }
    ```
  
  
    ```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
    }
    ```
  

[Go, Rust, Kotlin, .NET and embedded C](/developers/sdks/) make the same
calls in their own idiom, and the [MCP server](/developers/mcp/) does it for an
agent without any code at all.

## Already Set Up?