> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tavus.io/llms.txt
> Use this file to discover all available pages before exploring further.

# FAQs

> Frequently asked questions about Tavus's Conversational Video Interface.

<AccordionGroup>
  <Accordion title="Memories">
    <AccordionGroup>
      <Accordion title="What does a memory store represent?">
        A memory store represents the ongoing relationship between one PAL and one participant. It contains what the developer has told the PAL about that relationship, along with what the PAL has learned across their conversations.

        It is not a global participant profile. If the same participant interacts with another PAL, that relationship has its own memory store.
      </Accordion>

      <Accordion title="Can I give the PAL context before the first conversation?">
        Yes. You can add pinned memories when you create the memory store or anytime before starting the conversation. This lets the PAL begin its first interaction with participant-specific context such as their preferences, goals, account information, or other relevant history.
      </Accordion>

      <Accordion title="How should I identify a participant?">
        Pass one stable, non-empty tag in `participant_tags`, such as your internal user ID. The tag can be any string from your application; avoid values that may change, such as a display name.

        `participant_tags` accepts zero or one tag today. Sending more than one tag returns a `400` error because multi-participant memory is not supported yet.
      </Accordion>

      <Accordion title="What should I do if learned memory is incorrect?">
        Delete the incorrect profile field or timeline entry. If you know the correct information and want the PAL to treat it as authoritative, you can also add it as a pinned memory.

        Pinned memories take precedence over learned memory, but a replacement does not always need to be pinned. Deletion alone may be more appropriate when information should simply be forgotten or is uncertain.
      </Accordion>

      <Accordion title="Can multiple participants use the same memory store?">
        No. A memory store belongs to one relationship and should not be reused for different participants. Create a separate store for each relationship.

        Pinned memories are also scoped to an individual store. There is currently no shared collection of pinned memories across stores. Put stable guidance or background knowledge that should apply to everyone in the PAL's [system prompt](/sections/conversational-video-interface/pal/overview#pal-customization-options), rather than in relationship memory.
      </Accordion>

      <Accordion title="When does learned memory become available?">
        Learning begins asynchronously after a conversation ends and is typically available within a few minutes. This is not a guaranteed processing time. A new conversation started before processing completes will receive the relationship's previous memory state.

        If a workflow depends on the latest information, retrieve the memory store and confirm that it has been updated before starting the next conversation.
      </Accordion>

      <Accordion title="Will existing legacy memory tag integrations continue working?">
        Yes. Existing integrations that pass legacy memory tags through the `memory_stores` field will continue to work. New integrations should pass `participant_tags` when creating conversations. See [Maintaining a legacy memory tag integration](/sections/conversational-video-interface/tag-based-memories) for details.
      </Accordion>
    </AccordionGroup>
  </Accordion>

  <Accordion title="Knowledge Base">
    <AccordionGroup>
      <Accordion title="What is Knowledge Base and how does it work?">
        Knowledge Base is where users upload documents to enhance their AI PAL capabilities using RAG (Retrieval-Augmented Generation). By retrieving information directly from these documents, AI PALs can deliver more accurate, relevant, and grounded responses.
      </Accordion>

      <Accordion title="What happens during a conversation when using RAG?">
        Using RAG, the Knowledge Base system continuously:

        * Analyzes the conversation context
        * Retrieves relevant information from your document base
        * Augments the AI's responses with this contextual knowledge from your documents
      </Accordion>

      <Accordion title="How long does it take for knowledge to be retrieved?">
        With our industry-leading RAG, responses arrive in just 30 ms, up to 15× faster than other solutions. Conversations feel instant, natural, and friction-free.
      </Accordion>

      <Accordion title="What about customers who have already built their own Knowledge Base?">
        Yes, users can keep using their systems, but we strongly recommend they integrate with the Tavus Knowledge Base. Our Knowledge Base isn't just faster: it's the fastest RAG on the market, delivering answers in just 30 ms. That speed means conversations flow instantly, without awkward pauses or lagging. These interactions feel natural in a way user-built systems can't match.
      </Accordion>

      <Accordion title="Can you give an example of a Knowledge Base use case?">
        An AI recruiter can reference a candidate's resume uploaded via PDF and provide more accurate responses to applicant questions, using the resume content as grounding.
      </Accordion>

      <Accordion title="What's the customer value of Knowledge Base?">
        By having a Knowledge Base, AI PALs can respond with facts, unlocking domain-specific intelligence:

        * Faster onboarding (just upload the docs)
        * More trustworthy answers, especially in regulated or high-stakes environments
        * Higher task completion for users, thanks to grounded knowledge
      </Accordion>

      <Accordion title="What formats are supported for upload?">
        Supported file types (uploaded to a publicly accessible URL like S3):

        * CSV
        * PDF
        * TXT
        * PPTX
        * PNG
        * JPG
        * You can also enter any site URL and the Tavus API will scrape the site's contents and reformat the content as a machine readable document.
      </Accordion>

      <Accordion title="Where can I find more information about Knowledge Base?">
        Head to the [Knowledge Base Documentation site](https://docs.tavus.io/sections/conversational-video-interface/knowledge-base).
      </Accordion>

      <Accordion title="Are there any access limitations when using a document ID?">
        Yes. Documents are linked to the API key that was used to upload them. To access a document later, you must use the same API key that was used to create it.
      </Accordion>

      <Accordion title="How do I use Knowledge Base through the API?">
        Once your documents have been uploaded and processed, include their IDs in your conversation request. Here's how:

        ```bash theme={null}
        curl --location 'https://tavusapi.com/v2/conversations/' \
        --header 'Content-Type: application/json' \
        --header 'x-api-key: '<API KEY>' \
        --data '{
            "pal_id": "<PAL ID>",
            "face_id": "<Face ID>",
            "document_ids": ["Document ID"]
        }'
        ```

        Note: You can include multiple document\_ids, and your AI PAL will dynamically reference those documents during the conversation. You can also attach a document to a PAL.
      </Accordion>

      <Accordion title="How do I upload documents using API?">
        Upload files by providing a downloadable URL using the Create Documents endpoint. Tags are also supported for organization. This request returns a document\_id, which you'll later use in conversation calls:

        ```bash theme={null}
        curl --location 'https://tavusapi.com/v2/documents/' \
        --header 'Content-Type: application/json' \
        --header 'x-api-key: '<API Key>' \
        --data '{
            "document_url": "<publically accessible link>",
            "document_name": "slides_new.pdf",
            "tags": ["<tag-1>", "<tag-2>"]
        }'
        ```
      </Accordion>

      <Accordion title="What error codes might users encounter when uploading, accessing, or deleting documents, and what do they mean?">
        * `file_size_too_large` – File exceeds the maximum allowed upload size.
        * `file_format_unsupported` – This file type isn't supported for upload.
        * `invalid_file_url` – Provided file link is invalid or inaccessible.
        * `file_empty` – The uploaded file contains no readable content.
        * `website_processing_failed` – Website content could not be retrieved or processed.
        * `chunking_failed` – System couldn't split file into processable parts.
        * `embedding_failed` – Failed to generate embeddings for your file content.
        * `vector_store_failed` – Couldn't save data to the vector storage system.
        * `s3_storage_failed` – Error storing file in S3 cloud storage.
        * `contact_support` – An error occurred; please reach out for help.
      </Accordion>

      <Accordion title="How can I check the logs to see which document an AI PAL referenced in a response to a customer?">
        Conversation.rag.observability tool call will be sent, which will fire if the conversational LLM decides to use any of the document chunks in its response, returning the document IDs and document names of the chunks
      </Accordion>

      <Accordion title="What are the document_retrieval_strategy options?">
        When creating a conversation with documents, you can optimize how the system searches through your knowledge base by specifying a retrieval strategy. This strategy determines the balance between search speed and the quality of retrieved information, allowing you to fine-tune the system based on your specific needs.

        You can choose from three different strategies:

        * **Speed**: Optimizes for faster retrieval times for minimal latency.
        * **Balanced**: Provides a balance between retrieval speed and quality.
        * **Quality (default)**: Prioritizes finding the most relevant information, which may take slightly longer but can provide more accurate responses.
      </Accordion>

      <Accordion title="How long does it take for documents to be uploaded and usable?">
        Maximum of 5 mins.
      </Accordion>

      <Accordion title="Do we support all languages for the knowledge base?">
        No. Currently, we only support documents written in English.
      </Accordion>
    </AccordionGroup>
  </Accordion>

  <Accordion title="Objectives and Guardrails">
    <AccordionGroup>
      <Accordion title="Objectives - What are they? How do they work?">
        Users need AI that can drive conversations to clear outcomes. With Objectives, users can now can define objectives with measurable completion criteria, branch automatically based on user responses, and track progress in real time. This unlocks workflow use cases like Health Intakes, HR Interviews, and multi-step questionnaires.
      </Accordion>

      <Accordion title="How do I add Objectives to my PAL?">
        Objectives must be added or updated via API only. You cannot configure objectives during PAL creation in the UI. You can attach them using the API, either during PAL creation by including an objectives\_id, or by editing an existing PAL with a PATCH request.
      </Accordion>

      <Accordion title="What use cases are Objectives good for?">
        Objectives are good for very templated one-off conversational use cases. For example, job interviews or health care intake, where there is a very defined path that the conversation should take. These kinds of use cases usually show up with our Enterprise API customers, where they have repetitive use cases at scale.

        More dynamic, free-flowing conversations usually do not benefit from having or enabling the Objectives feature. For example, talking with a Travel advisor where the conversation is very open ended, would usually not benefit from Objectives.

        Objectives are good for very defined workflows. Complex multi-session experiences don't fit current Objectives framework.
      </Accordion>

      <Accordion title="Where can I find more information about Objectives?">
        Head to the [Objectives Documentation site](https://docs.tavus.io/sections/conversational-video-interface/pal/objectives).
      </Accordion>

      <Accordion title="Guardrails - What are they? How do they work?">
        Guardrails help ensure your AI PAL stays within appropriate boundaries and follows your defined rules during conversations.
      </Accordion>

      <Accordion title="How do I add Guardrails to my PAL?">
        Guardrails must be added or updated via API only. You cannot configure guardrails during PAL creation in the UI. You can attach them via the API, either during PAL creation by adding a guardrails\_id, or by editing an existing PAL with a PATCH request.
      </Accordion>

      <Accordion title="Can I create different Guardrails for different PALs?">
        Yes. You might have one set of Guardrails for a healthcare assistant to ensure medical compliance, and another for an education-focused PAL to keep all conversations age-appropriate.
      </Accordion>

      <Accordion title="Where can I find more information about Guardrails?">
        Head to the [Guardrails Documentation site](https://docs.tavus.io/sections/conversational-video-interface/guardrails).
      </Accordion>
    </AccordionGroup>
  </Accordion>

  <Accordion title="General Tavus Q&A">
    <AccordionGroup>
      <Accordion title="What is Daily?">
        **Daily** is a platform that offers prebuilt video call apps and APIs, allowing you to easily integrate video chat into your web applications. You can embed a customizable video call widget into your site with just a few lines of code and access features like screen sharing and recording. **Tavus partners with Daily to power video conversations with our faces.**
      </Accordion>

      <Accordion title="Do I need a Daily account?">
        * You **do not** need to sign up for a Daily account to use Tavus's Conversational Video Interface.
        * All you need is the Daily room URL (called `conversation_url` in our system) that is returned by the Tavus API. You can serve this link directly to your end users or embed it.
      </Accordion>

      <Accordion title="How do I embed the conversation using Daily's Prebuilt UI?">
        You can use Daily Prebuilt if you want a full-featured call UI and JavaScript control over the conversation. Once you have the Daily room URL (`conversation_url`) ready, replace `DAILY_ROOM_URL` in the code snippet below with your room URL.

        ```html theme={null}
        <html>
          <script crossorigin src="https://unpkg.com/@daily-co/daily-js"></script>
          <body>
            <script>
              call = window.Daily.createFrame();
              call.join({ url: 'DAILY_ROOM_URL' });
            </script>
          </body>
        </html>
        ```

        That's it! For more details and options for embedding, check out <a href="https://docs.daily.co/guides/products/prebuilt#step-by-step-guide-embed-daily-prebuilt" target="_blank">Daily's documentation.</a> or [our implementation guides](https://docs.tavus.io/sections/integrations/embedding-cvi#how-can-i-reduce-background-noise-during-calls).
      </Accordion>

      <Accordion title="How do I embed the conversation using an iframe?">
        You can use an iframe if you just want to embed the conversation video with minimal setup. Once you have the Daily room URL (`conversation_url`) ready, replace `YOUR_TAVUS_MEETING_URL` in the iframe code snippet below with your room URL.

        ```html theme={null}
        <html>
          <body>
            <iframe
              src="YOUR_TAVUS_MEETING_URL"
              allow="camera; microphone; fullscreen; display-capture"
              style="width: 100%; height: 500px; border: none;">
            </iframe>
          </body>
        </html>
        ```

        That's it! For more details and options for embedding, check out <a href="https://docs.daily.co/guides/products/prebuilt#step-by-step-guide-embed-daily-prebuilt" target="_blank">Daily's documentation.</a> or [our implementation guides](https://docs.tavus.io/sections/integrations/embedding-cvi#how-can-i-reduce-background-noise-during-calls).
      </Accordion>

      <Accordion title="How can I add custom LLM layers?">
        To add a custom LLM layer, you'll need the model name, base URL, and API key from your LLM provider. Then, include the LLM config in your `layers` field when creating a PAL using the <a href="/api-reference/pals/create-pal" target="_blank">Create PAL API</a>. Example configuration:

        ```json {8-13} theme={null}
        {
          "pal_name": "Storyteller",
          "system_prompt": "You are a storyteller who entertains people of all ages.",
          "context": "Your favorite stories include Little Red Riding Hood and The Three Little Pigs.",
          "pipeline_mode": "full",
          "default_face_id": "rc9cff32ceba",
          "layers": {
            "llm": {
              "model": "gpt-3.5-turbo",
              "base_url": "https://api.openai.com/v1",
              "api_key": "your-api-key",
              "speculative_inference": true
            }
          }
        }
        ```

        For more details, refer to our [Large Language Model (LLM) documentation](/sections/conversational-video-interface/pal/llm#custom-llms).
      </Accordion>

      <Accordion title="How do I modify TTS voices?">
        Create a voice in [PAL Maker](https://maker.tavus.io/dev/voices/create), then set its `voice_id` on the PAL's tts object. Tavus picks the provider and model that are the best fit for the language(s) of the conversation:

        ```json theme={null}
        {
          "layers": {
            "tts": {
              "voice_id": "v0a1b2c3d4e5f"
            }
          }
        }
        ```

        To use a voice from your own Cartesia, ElevenLabs, or Azure account instead, set `external_voice_id` with that provider's `tts_engine` and `api_key`:

        ```json theme={null}
        {
          "layers": {
            "tts": {
              "tts_engine": "cartesia",
              "api_key": "your-tts-provider-api-key",
              "external_voice_id": "your-voice-id"
            }
          }
        }
        ```

        For more details, read more on [our TTS documentation](/sections/conversational-video-interface/pal/tts).
      </Accordion>

      <Accordion title="How do I add callback URLs?">
        You need to create a webhook endpoint that can receive POST requests from Tavus. This endpoint will receive the callback events for the visual summary after the conversation ended. Then, add `callback_url` property when creating the conversation

        ```sh {8} theme={null}
        curl --request POST \
          --url https://tavusapi.com/v2/conversations \
          --header 'Content-Type: application/json' \
          --header 'x-api-key: <api_key>' \
          --data '{
        "pal_id": "pcb7a34da5fe",
            "face_id": "rc9cff32ceba",
          "callback_url": "your_webhook_url"
        }'
        ```
      </Accordion>

      <Accordion title="How do I get transcripts for my conversation?">
        You need to create a webhook endpoint that can receive `POST` requests from Tavus. This endpoint will receive the callback events for the transcripts after the conversation ended. Then, add `callback_url` property when creating the conversation.

        ```sh {8} theme={null}
        curl --request POST \
          --url https://tavusapi.com/v2/conversations \
          --header 'Content-Type: application/json' \
          --header 'x-api-key: <api_key>' \
          --data '{
        "pal_id": "pcb7a34da5fe",
            "face_id": "rc9cff32ceba",
          "callback_url": "your_webhook_url"
        }'
        ```

        Your backend then will receive an event with properties `event_type = application.transcription_ready` when the transcript is ready.

        ```json application.transcription_ready [expandable] theme={null}
        {
          "properties": {
            "face_id": "<face_id>",
            "transcript": [
              {
                "role": "system",
                "content": "You are in a live video conference call with a user. You will get user message with two identifiers, 'USER SPEECH:' and 'VISUAL SCENE:', where 'USER SPEECH:' is what the person actually tells you, and 'VISUAL SCENE:' is what you are seeing when you look at them. Only use the information provided in 'VISUAL SCENE:' if the user asks what you see. Don't output identifiers such as 'USER SPEECH:' or 'VISUAL SCENE:' in your response. Reply in short sentences, talk to the user in a casual way.Respond only in english.   "
              },
              {
                "role": "user",
                "content": " Hello, tell me a story. "
              },
              {
                "role": "assistant",
                "content": "I've got a great one about a guy who traveled back in time.  Want to hear it? "
              },
              {
                "role": "user",
                "content": "USER_SPEECH:  Yeah I'd love to hear it.  VISUAL_SCENE: The image shows a close-up of a person's face, focusing on their forehead, eyes, and nose. In the background, there is a television screen mounted on a wall. The setting appears to be indoors, possibly in a public or commercial space."
              },
              {
                "role": "assistant",
                "content": "Let me think for a sec.  Alright, so there was this mysterious island that appeared out of nowhere,  and people started disappearing when they went to explore it.  "
              },
            ]
          },
          "conversation_id": "<your_conversation_id>",
          "webhook_url": "<your_webhook_url>",
          "message_type": "application",
          "event_type": "application.transcription_ready",
          "timestamp": "2025-02-10T21:30:06.141454Z"
        }
        ```
      </Accordion>

      <Accordion title="How do I get visual summary for my conversation?">
        You need to create a webhook endpoint that can receive `POST` requests from Tavus. This endpoint will receive the callback events for the visual summary after the conversation ended. Then, add `callback_url` property when creating the conversation.

        ```sh {8} theme={null}
        curl --request POST \
          --url https://tavusapi.com/v2/conversations \
          --header 'Content-Type: application/json' \
          --header 'x-api-key: <api_key>' \
          --data '{
        "pal_id": "pcb7a34da5fe",
            "face_id": "rc9cff32ceba",
          "callback_url": "your_webhook_url"
        }'
        ```

        Your backend then will receive an event with properties `event_type = application.perception_analysis` when the summary is ready.

        ```json application.perception_analysis theme={null}
        {
          "properties": {
            "analysis": "Here's a summary of the visual observations from the video call:\n\n*   **Overall Demeanor & Emotional State:** The user consistently appeared calm, collected, and neutral. They were frequently described as pensive, contemplative, or focused, suggesting they were often engaged in thought or listening attentively. No strong positive or negative emotions were consistently detected.\n\n*   **Appearance:**\n    *   The user is a young Asian male, likely in his early 20s, with dark hair.\n    *   He consistently wore a black shirt, sometimes specifically identified as a black t-shirt. One observation mentioned a \"1989\" print on the shirt.\n    *   He was consistently looking directly at the camera.\n\n*   **Environment:** The user was consistently in an indoor setting, most likely an office or home. Common background elements included:\n    *   White walls.\n    *   Windows or glass panels/partitions, often with black frames.\n    *   Another person was partially visible in the background for several observations.\n\n*   **Actions:**\n    *   The user was seen talking and gesturing with his hand in one observation, indicating he was actively participating in a conversation.\n\n*   **Ambient Awareness Queries:**\n    *   **Acne:** Acne was initially detected on the user's face in one observation, but later observations did not detect it. This suggests that acne may have been visible at one point but not throughout the entire call.\n    *   **Distress/Discomfort:** No signs of distress or discomfort were observed at any point during the call."
          },
          "conversation_id": "<your_conversation_id>",
          "webhook_url": "<your_webhook_url>",
          "message_type": "application",
          "event_type": "application.perception_analysis",
          "timestamp": "2025-06-19T06:57:32.480826Z"
        }
        ```
      </Accordion>

      <Accordion title="What is the maximum context window supported by the default LLM?">
        * Context limits vary by model. For best speed and instruction following, keep prompts under **5,000 tokens**.
        * Contexts over **25,000 tokens** will experience noticeable performance degradation (slower response times).

        <Tip>
          1 token ≈ 4 characters; therefore 32,000 tokens ≈ 128,000 characters (including spaces and punctuation).
        </Tip>
      </Accordion>

      <Accordion title="How do I add perception tool calls?">
        Create vision or audio tools in the [tools registry](/sections/conversational-video-interface/pal/tools) with `origin: "vision"` or `"audio"`, then attach them to your PAL. See [Tool Calling for Perception](/sections/conversational-video-interface/pal/perception-tool) for examples and the full flow.

        ```bash theme={null}
        curl --request POST \
          --url https://tavusapi.com/v2/tools \
          --header 'Content-Type: application/json' \
          --header 'x-api-key: <api-key>' \
          --data '{
            "name": "notify_if_id_shown",
            "description": "Trigger when a driver'\''s license or passport is clearly visible",
            "parameters": {
              "type": "object",
              "properties": {
                "id_type": { "type": "string", "description": "Best guess on ID type" }
              },
              "required": ["id_type"]
            },
            "origin": "vision"
          }'
        ```

        Pair perception tools with [`visual_awareness_queries`](/sections/conversational-video-interface/pal/perception#2-visual_awareness_queries) and [`audio_awareness_queries`](/sections/conversational-video-interface/pal/perception#6-audio_awareness_queries) on the PAL's `perception` layer so Raven knows what to watch for during the call. See [Perception](/sections/conversational-video-interface/pal/perception) for the full layer reference, including legacy `visual_tool_prompt` and `audio_tool_prompt` fields.

        <Note>
          **Legacy inline tools:** Older PALs embed tools under `layers.perception.visual_tools` or `layers.perception.audio_tools`. That still works but is deprecated. See [Legacy inline tool calling](/sections/troubleshooting#legacy-inline-tool-calling).
        </Note>
      </Accordion>

      <Accordion title="Do I need to invite the PAL to the meeting room?">
        It depends on how the conversation starts:

        * **Daily CVI** (you create a conversation and open the returned `conversation_url`): No separate invite step. The PAL joins the Daily room automatically when it's ready.
        * **[Google Meet / Zoom / Teams](/sections/conversational-video-interface/pal/meetings)** (PAL conferencing email): Invite the PAL's conferencing address to a calendar event with a Google Meet, Zoom, or Microsoft Teams link. It accepts and joins scheduled meetings about one minute before start time, or joins calls already in progress shortly after the invite.
      </Accordion>

      <Accordion title="Can participants interrupt the face's greeting?">
        No - the PAL always finishes its greeting before it starts listening. Anything a participant says during the greeting is ignored and won't appear in the conversation transcript. Normal conversation starts as soon as the greeting completes. The participant's mic stays on, so their audio is still captured in call recordings. Applies to Daily-based CVI only (not [LiveKit](/sections/integrations/livekit) or [Pipecat](/sections/integrations/pipecat)).
      </Accordion>

      <Accordion title="For CVI, what's customizable vs. out of the box?">
        Out of the box, Tavus handles the complex backend infrastructure for you: LLMs, rendering, video delivery, and conversational intelligence are all preconfigured and production-ready.

        From there, nearly everything else is customizable:
        • What your AI PAL sees
        • How they look and sound
        • How they behave in conversation

        Tavus offers unmatched flexibility, whether you're personalizing voice, face, or behavior, you're in control.
      </Accordion>

      <Accordion title="How does Tavus deliver real-time responsiveness?">
        Tavus uses WebRTC to power real-time, face-to-face video interactions with extremely low latency.

        Unlike other platforms that piece together third-party tools, we built the entire pipeline (from LLM to rendering) to keep latency low and responsiveness high. Ironically, by minimizing reliance on multiple APIs, we've made everything faster.
      </Accordion>

      <Accordion title="What's behind the scenes of CVI?">
        Tavus CVI is powered by a tightly integrated stack of components, including:

        * LLMs for natural language understanding
        * Real-time rendering for facial video
        * APIs for PAL creation and conversational control

        You can explore key APIs here:
        • [Create a PAL](/api-reference/pals/create-pal)
        • [Create a Conversation](/api-reference/conversations/create-conversation)
      </Accordion>

      <Accordion title="How many languages does Tavus support?">
        Tavus speaks 42 languages with the default `tavus-auto` TTS engine, which picks the provider and model that fit the languages of the conversation. If you need a language outside that set, Azure may cover it as a fallback.

        The supported languages are Arabic, Bengali, Bulgarian, Chinese, Croatian, Czech, Danish, Dutch, English, Finnish, French, Georgian, German, Greek, Gujarati, Hebrew, Hindi, Hungarian, Indonesian, Italian, Japanese, Kannada, Korean, Malay, Malayalam, Marathi, Norwegian, Polish, Portuguese, Punjabi, Romanian, Russian, Slovak, Spanish, Swedish, Tagalog, Tamil, Telugu, Thai, Turkish, Ukrainian, Vietnamese.

        View the [full supported language list](https://docs.tavus.io/sections/conversational-video-interface/language-support) for complete details and language-specific information.
      </Accordion>

      <Accordion title="Can Tavus support different accents or dialects?">
        Yes to accents. Not quite for regional dialects.

        When you generate a voice using Tavus, the system will default to the accent used in training. For example, if you provide Brazilian Portuguese as training input, the AI PAL will speak with a Brazilian accent. Tavus' TTS providers auto-detect and match accordingly.
      </Accordion>

      <Accordion title="What can Tavus do when it comes to orchestration (calendars, email tools, HubSpot, DocuSign, etc.)?">
        Tavus supports full orchestration through [tool calling](/sections/conversational-video-interface/pal/tools). Define tools in the registry, attach them to a PAL, and handle `conversation.tool_call` events in your app - or let Tavus call your HTTPS endpoints directly via API delivery.

        Bonus: As of August 11, 2025, Tavus also supports Retrieval-Augmented Generation (RAG), so your AI PAL can pull information from your uploaded documents, images, or websites to give even smarter responses.

        Learn more via [Tavus Documentation](/sections/conversational-video-interface).
      </Accordion>

      <Accordion title="What makes a good prompt? How much does Tavus help with that?">
        A good prompt is short, clear, and specific, like giving directions to a 5-year-old. Avoid data dumping. Instead, guide the AI with context and intent.

        Tavus helps by offering system prompt templates, use-case guidance, and API fields to structure your instructions.
      </Accordion>

      <Accordion title="How do I add a custom LLM to CVI?">
        You can bring your own LLM by configuring the layers field in the Create PAL API. Here's an example:

        ```json theme={null}
        {
          "pal_name": "Storyteller",
          "system_prompt": "You are a storyteller who entertains people of all ages.",
          "context": "Your favorite stories include Little Red Riding Hood and The Three Little Pigs.",
          "pipeline_mode": "full",
          "default_face_id": "rc9cff32ceba",
          "layers": {
            "llm": {
              "model": "gpt-3.5-turbo",
              "base_url": "https://api.openai.com/v1",
              "api_key": "your-api-key",
              "speculative_inference": true
            }
          }
        }
        ```

        More info here: [LLM Documentation](https://docs.tavus.io/sections/conversational-video-interface/pal/llm#custom-llms)
      </Accordion>

      <Accordion title="How customizable is the user interface? What does Tavus provide?">
        Think of it this way: Tavus is the engine, and you design the car. The UI is 100% up to you.

        To make it easier, we offer a full [Component Library](/sections/conversational-video-interface/component-library) you can copy and paste into your build - video frames, mic/camera toggles, and more.
      </Accordion>

      <Accordion title="How do I change the AI PAL's voice?">
        Set a [Voice](/sections/conversational-video-interface/voices) on the PAL's tts object by `voice_id`:

        ```json theme={null}
        {
          "layers": {
            "tts": {
              "voice_id": "v0a1b2c3d4e5f"
            }
          }
        }
        ```

        To use a voice from your own Cartesia, ElevenLabs, or Azure account instead, set `external_voice_id` with that provider's `tts_engine` and `api_key`:

        ```json theme={null}
        {
          "layers": {
            "tts": {
              "tts_engine": "cartesia",
              "api_key": "your-tts-provider-api-key",
              "external_voice_id": "your-voice-id"
            }
          }
        }
        ```

        Learn more in our [TTS Documentation](/sections/conversational-video-interface/pal/tts).
      </Accordion>

      <Accordion title="How can I reduce background noise during calls?">
        Use `sparrow-2`, which analyzes the full audio stream and uses background sound as context instead of requiring noise to be stripped away before turn detection. This improves turn-taking in loud and shared environments. The `voice_isolation` parameter remains available, but is not used by `sparrow-2`; it currently affects audio processing only when using `sparrow-1`.

        Daily also exposes client-side noise cancellation through `updateInputSettings()` (`audio.processor.type: 'noise-cancellation'`; in Daily Prebuilt, **Reduce mic noise**). Leave this off. Using Daily noise cancellation together with Sparrow-2 can strip too much sound and context that Sparrow-2 relies on.

        Learn more in our [Conversational Flow documentation](/sections/conversational-video-interface/pal/conversational-flow).
      </Accordion>

      <Accordion title="Can I track events in the video call?">
        Yes! Daily supports event listeners you can hook into. Track actions like participants joining, leaving, screen sharing, and more. Great for analytics or triggering workflows.
      </Accordion>

      <Accordion title="How do you change or customize the background in CVI?">
        Set `apply_greenscreen` to `true` in the `properties` object when creating a conversation. The PAL's background is replaced with a green screen, which you can then make transparent or replace with a custom color or image on your frontend using WebGL. See [Background Customizations](/sections/conversational-video-interface/conversation/customizations/background-customizations) for a full walkthrough.

        Background customization is not compatible with Phoenix-4.5 faces.
      </Accordion>

      <Accordion title="What compliance and security standards does Tavus meet?">
        Tavus is built with enterprise-grade security in mind. We're:

        * SOC 2 compliant
        * GDPR compliant
        * HIPAA compliant
        * BAA compliant

        This ensures your data is handled with the highest levels of care and control.
      </Accordion>
    </AccordionGroup>
  </Accordion>

  <Accordion title="Billing">
    Find answers to common questions about plans, usage-based billing, overages, invoices, and account management.

    <AccordionGroup>
      <Accordion title="Where can I view my current usage and billing information?">
        You can view your current plan, usage, invoice history, and billing history anytime in the PAL Maker [billing dashboard](https://maker.tavus.io/dev/billing).
      </Accordion>

      <Accordion title="Why was I billed for more conversation minutes than expected?">
        Conversation billing is based on active session runtime, not just the amount of time spent actively speaking. If conversations remain open, idle, or connected without adjusted timeout settings, usage may continue accumulating GPU runtime costs even when no one is actively participating in the call.

        Be sure to review and configure your session timeout and idle timeout settings appropriately to avoid unexpected usage charges. For more details, see [Call Duration and Timeout](/sections/conversational-video-interface/conversation/customizations/call-duration-and-timeout).
      </Accordion>

      <Accordion title="Can I update my billing information?">
        Yes. You can update your payment method and billing details anytime through the PAL Maker [billing dashboard](https://maker.tavus.io/dev/billing).
      </Accordion>

      <Accordion title="Why was I charged for additional faces?">
        Your plan includes a fixed number of faces. If you create more faces than your plan allows, additional overage charges may apply. Please review our [pricing page](https://www.tavus.io/pricing) for more details.
      </Accordion>

      <Accordion title="What happens if I exceed my plan limits?">
        If your usage exceeds the limits included in your plan, overage charges may apply automatically based on your subscription. Depending on your usage volume, you may receive multiple overage charges within a single billing cycle once certain thresholds are exceeded.

        Please review our [pricing page](https://www.tavus.io/pricing) for more details on overages.
      </Accordion>

      <Accordion title="Do failed face training attempts count toward billing?">
        Failed training attempts do not count as successful faces, and therefore do not consume credits.
      </Accordion>

      <Accordion title="Can invoices be reissued after billing information is updated?">
        Once an invoice has been finalized and issued, it typically cannot be modified or reissued retroactively. Updated billing details will apply to future invoices.
      </Accordion>

      <Accordion title="How do I cancel or change my subscription plan?">
        You can manage, upgrade, or cancel your subscription directly from the PAL Maker billing settings.
      </Accordion>

      <Accordion title="Do unused faces or credits roll over to the next billing cycle?">
        Unused plan allocations and credits do not roll over unless explicitly stated in your plan terms.
      </Accordion>

      <Accordion title="Why was my payment declined?">
        Payments may fail due to expired cards, insufficient funds, bank restrictions, payment authorization issues, or missing e-mandate approvals.

        For Indian cards, banks require an e-mandate to be configured before recurring or international payments can be processed successfully.
      </Accordion>
    </AccordionGroup>
  </Accordion>

  <Accordion title="Teams">
    <AccordionGroup>
      <Accordion title="What happens when I add someone to my account?">
        Adding someone to your account means they operate under your account's billing plan.
      </Accordion>

      <Accordion title="Are assets shared across team members?">
        No. Assets are permission-bounded to the individual account that created them.
      </Accordion>
    </AccordionGroup>
  </Accordion>
</AccordionGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.