Build a Multilingual Chatbot with LLM Resayil API

Introduction

Building a multilingual chatbot that supports Arabic and other languages can be challenging with standard LLM APIs. Many providers focus primarily on English, leaving developers to handle translation layers or limited language support. LLM Resayil offers a solution with its OpenAI and Anthropic-compatible API, designed specifically for multilingual applications, including native Arabic language processing.

In this guide, we’ll walk through setting up a multilingual chatbot using the LLM Resayil API. You’ll learn how to configure billing, authenticate API requests, implement chat completions, and leverage advanced features like streaming, function calling, and vision. Whether you’re using Python or JavaScript, this step-by-step tutorial will help you integrate LLM Resayil into your project seamlessly.

Understanding LLM Resayil API Features

Before diving into implementation, it’s essential to understand the key features of the LLM Resayil API that make it ideal for multilingual chatbots.

Arabic and Multilingual Support

LLM Resayil is built with native Arabic language support, ensuring accurate and context-aware responses for Arabic-speaking users. Unlike many LLM APIs that treat Arabic as an afterthought, LLM Resayil’s models are optimized for Arabic grammar, syntax, and cultural nuances. Additionally, the API supports multiple languages, allowing you to build chatbots that cater to a global audience without relying on external translation services.

Active Model Catalog

The LLM Resayil API offers access to 33 active models, including:

• Thinking models: Ideal for complex reasoning tasks (e.g., DeepSeek V4 Pro, Kimi K2.6, Qwen 3.5 397B).
• Chat models: Optimized for conversational applications (e.g., Nemotron 3 Super, MiniMax M2.7).
• Vision models: Enable image understanding and analysis (e.g., GLM-5.1, GLM-5).
• Code models: Designed for programming assistance (e.g., Devstral 2 123B, Qwen 3 Coder 480B).

This diverse catalog ensures you can select the best model for your chatbot’s specific needs, whether it’s handling customer support queries, generating creative content, or assisting with technical tasks.

OpenAI and Anthropic Compatibility

One of the standout features of LLM Resayil is its compatibility with both OpenAI and Anthropic SDKs. This means you can integrate the API into your existing workflows without rewriting your codebase. If you’re already using the OpenAI Python library or Anthropic’s JavaScript SDK, switching to LLM Resayil is as simple as updating your API endpoint and model slug.

LLM Resayil vs. Standard OpenAI API for Multilingual Chatbots

When building a multilingual chatbot, choosing the right API provider is critical. Below is a comparison of what LLM Resayil offers versus the standard OpenAI API for key features relevant to multilingual applications.

| Feature | LLM Resayil API | Standard OpenAI API | |-----------------------------|------------------------------------------|-----------------------------------------| | OpenAI SDK Compatibility | Yes | Yes | | Anthropic SDK Compatibility | Yes | No | | Arabic Language Support | Native support | Limited support (requires workarounds) | | Multilingual Support | Yes | Yes (but not optimized for all languages) | | Thinking Models | Yes (e.g., DeepSeek V4 Pro, Kimi K2.6) | Limited (e.g., o1, o3 reasoning models) | | Vision Models | Yes (e.g., GLM-5.1) | Yes (e.g., GPT-4 Vision) | | Function Calling | Yes | Yes | | Tool Use | Yes | Yes | | Streaming | Yes | Yes | | Pay-Per-Use Pricing | Yes | Yes | | Hosting Location | USA | USA | | Supported Currencies | USD | USD | | Payment Methods | Stripe, PayPal | Credit card, Microsoft Azure credits |

What LLM Resayil Offers

LLM Resayil is designed with multilingual applications in mind. Its native Arabic support ensures high-quality responses without the need for additional translation layers. The API is also compatible with both OpenAI and Anthropic SDKs, giving developers flexibility in how they integrate it into their projects. With 33 active models, including thinking, chat, vision, and code models, you can tailor your chatbot’s capabilities to your specific use case.

The API also supports advanced features like streaming, function calling, vision, and tool use, making it suitable for a wide range of applications, from customer support to creative content generation.

What Standard OpenAI API Offers

The standard OpenAI API is a powerful tool for building chatbots, particularly for English-language applications. It supports multilingual capabilities, but its performance in non-English languages, including Arabic, may require additional fine-tuning or translation layers. OpenAI’s API is compatible with its own SDKs and offers features like function calling, vision, and streaming. However, it lacks native compatibility with Anthropic’s SDKs, which may limit flexibility for some developers.

Why LLM Resayil Wins for Multilingual Chatbots

For developers building multilingual chatbots, especially those targeting Arabic-speaking audiences, LLM Resayil offers several advantages:

1. Native Arabic Support: No need for external translation services or workarounds. LLM Resayil’s models are optimized for Arabic grammar and context.
2. SDK Flexibility: Compatibility with both OpenAI and Anthropic SDKs means you can use the tools you’re already familiar with.
3. Diverse Model Catalog: Access to 33 models, including specialized thinking and vision models, allows you to build more sophisticated chatbots.
4. Pay-Per-Use Pricing: Simple and transparent pricing with no hidden fees.

Setting Up Billing and Authentication

Before you can start using the LLM Resayil API, you’ll need to set up billing and authenticate your requests. Here’s a step-by-step guide to getting started.

Step 1: Create an Account

1. Visit the LLM Resayil Portal and sign up for an account.
2. Verify your email address to activate your account.

Step 2: Configure Billing

LLM Resayil uses a pay-per-use credit system, and all transactions are billed in USD. You can top up your account using one of the following payment methods:

• Stripe: Accepts major credit and debit cards.
• PayPal: Supports PayPal payments.

To add credits to your account:

1. Navigate to the Pricing page.
2. Select a top-up amount and proceed to checkout.
3. Choose your preferred payment method (Stripe or PayPal) and complete the transaction.

Step 3: Generate an API Key

Once your account is funded, you’ll need an API key to authenticate your requests. Here’s how to generate one:

1. Log in to your LLM Resayil account.
2. Go to the API documentation for instructions on generating an API key.
3. Copy your API key and store it securely. Never share your API key publicly, as it grants access to your account.

Step 4: Authenticate API Requests

All API requests must include your API key in the Authorization header. Here’s an example of how to authenticate a request using curl:

curl https://llm.resayil.io/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "مرحبا، كيف حالك؟"}]
  }'

Replace YOUR_API_KEY with your actual API key. For Python or JavaScript, you’ll use the same header in your SDK requests.

Implementing Chat Completions with SDKs

Now that your account is set up and authenticated, let’s implement chat completions using the LLM Resayil API. We’ll cover integration with both Python and JavaScript, using the OpenAI and Anthropic SDKs.

Using the OpenAI Python SDK

If you’re already using the OpenAI Python library, integrating LLM Resayil is straightforward. Here’s how to get started:

1. Install the OpenAI Python SDK (if you haven’t already):

   pip install openai
   

2. Initialize the client with your API key and endpoint:

   from openai import OpenAI
   
   client = OpenAI(
       api_key="YOUR_API_KEY",
       base_url="https://llm.resayil.io/v1"
   )
   

3. Send a chat completion request:

   response = client.chat.completions.create(
       model="kimi-k2.6",
       messages=[
           {"role": "system", "content": "You are a helpful assistant."},
           {"role": "user", "content": "مرحبا، كيف يمكنني مساعدتك اليوم؟"}
       ]
   )
   print(response.choices[0].message.content)
   

Using the Anthropic JavaScript SDK

For JavaScript developers, the Anthropic SDK provides a seamless way to integrate LLM Resayil. Here’s how to use it:

1. Install the Anthropic SDK:

   npm install @anthropic-ai/sdk
   

2. Initialize the client with your API key and endpoint:

   const Anthropic = require('@anthropic-ai/sdk');
   
   const anthropic = new Anthropic({
       apiKey: "YOUR_API_KEY",
       baseURL: "https://llm.resayil.io/v1"
   });
   

3. Send a chat completion request:

   async function main() {
       const response = await anthropic.messages.create({
           model: "kimi-k2.6",
           max_tokens: 1024,
           messages: [
               {"role": "user", "content": "مرحبا، كيف حالك اليوم؟"}
           ]
       });
       console.log(response.content[0].text);
   }
   main();
   

Handling Multilingual Inputs

LLM Resayil’s models are designed to handle multilingual inputs seamlessly. Whether your chatbot is processing Arabic, English, or any other supported language, the API will return contextually accurate responses. Here’s an example of a multilingual conversation:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {"role": "user", "content": "Hello! كيف حالك اليوم؟"},
        {"role": "assistant", "content": "I'm doing well, thank you! أنا بخير، شكراً لك. How can I assist you?"},
        {"role": "user", "content": "Can you help me with a Python code snippet?"}
    ]
)
print(response.choices[0].message.content)

This example demonstrates how the API can switch between languages effortlessly, making it ideal for multilingual chatbots.

Utilizing Advanced Chatbot Capabilities

Beyond basic chat completions, the LLM Resayil API offers several advanced features to enhance your chatbot’s functionality. Let’s explore how to implement these features.

Streaming Responses

Streaming allows your chatbot to respond in real-time, improving user engagement. Here’s how to implement streaming with the OpenAI Python SDK:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://llm.resayil.io/v1"
)

stream = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "Tell me a story about a robot learning Arabic."}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

For JavaScript, you can use the Anthropic SDK to achieve the same effect:

const response = await anthropic.messages.create({
    model: "kimi-k2.6",
    max_tokens: 1024,
    messages: [{"role": "user", "content": "Tell me a story about a robot learning Arabic."}],
    stream: true
});

for await (const chunk of response) {
    if (chunk.delta.text) {
        process.stdout.write(chunk.delta.text);
    }
}

Function Calling

Function calling enables your chatbot to interact with external tools or APIs. For example, you can use function calling to fetch weather data, book appointments, or retrieve information from a database. Here’s an example using the OpenAI Python SDK:

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather in a given location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g., San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "What's the weather in Dubai?"}],
    tools=tools
)

print(response.choices[0].message.tool_calls)

Vision Capabilities

LLM Resayil’s vision models allow your chatbot to analyze and describe images. This is useful for applications like image captioning, visual question answering, or content moderation. Here’s how to use vision with the OpenAI Python SDK:

response = client.chat.completions.create(
    model="glm-5.1",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/image.jpg"}
                }
            ]
        }
    ]
)
print(response.choices[0].message.content)

Tool Use

Tool use extends function calling by allowing your chatbot to interact with predefined tools. For example, you can integrate tools for translation, calculations, or database queries. Here’s an example of tool use with the Anthropic JavaScript SDK:

const tools = [
    {
        name: "translate_text",
        description: "Translate text from one language to another",
        input_schema: {
            type: "object",
            properties: {
                text: { type: "string" },
                target_language: { type: "string" }
            },
            required: ["text", "target_language"]
        }
    }
];

const response = await anthropic.messages.create({
    model: "kimi-k2.6",
    max_tokens: 1024,
    messages: [{"role": "user", "content": "Translate 'Hello' to Arabic."}],
    tools: tools
});

console.log(response.content[0].tool_use);

FAQ

Conclusion

Building a multilingual chatbot with the LLM Resayil API is a straightforward process, thanks to its OpenAI and Anthropic compatibility, native Arabic support, and diverse model catalog. Whether you’re developing a customer support bot, a creative writing assistant, or a technical tool, LLM Resayil provides the features and flexibility you need to succeed.

In this guide, we covered:

1. The key features of the LLM Resayil API, including Arabic and multilingual support.
2. How to set up billing and authenticate API requests.
3. Implementing chat completions using Python and JavaScript SDKs.
4. Leveraging advanced features like streaming, function calling, vision, and tool use.

Ready to get started? Visit the LLM Resayil Portal to create an account, explore the Pricing page to top up your credits, and check out the API documentation for detailed integration guides.

Start building your multilingual chatbot today with LLM Resayil!