X (Twitter)

Docs

Build a Chatbot

Create a conversational AI chatbot using the Elyxir API.

This tutorial walks you through building a simple chatbot using the Elyxir API. You'll create a Python application that maintains conversation context and responds intelligently.

Prerequisites

Elyxir account and API key
Python 3.8 or later
Basic Python knowledge

Project Setup

Install Dependencies

pip install requests

Set Up Environment

Create a .env file:

ELYXIR_API_KEY=elyxir_your_api_key

Building the Chatbot

Step 1: Basic Structure

Create chatbot.py:

import os
import requests
 
API_KEY = os.environ.get("ELYXIR_API_KEY")
API_URL = "https://api.elyxir.ai/v1/chat/completions"
 
def chat(messages):
    """Send messages to Elyxir and get a response."""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
 
    payload = {
        "model": "gpt-4o-mini",
        "messages": messages,
        "temperature": 0.7
    }
 
    response = requests.post(API_URL, headers=headers, json=payload)
    response.raise_for_status()
 
    return response.json()["choices"][0]["message"]["content"]

Step 2: Conversation Loop

Add conversation handling:

def main():
    print("Chatbot ready! Type 'quit' to exit.\n")
 
    # Initialize conversation with system message
    messages = [
        {
            "role": "system",
            "content": "You are a helpful assistant. Be concise and friendly."
        }
    ]
 
    while True:
        # Get user input
        user_input = input("You: ").strip()
 
        if user_input.lower() == "quit":
            print("Goodbye!")
            break
 
        if not user_input:
            continue
 
        # Add user message to history
        messages.append({"role": "user", "content": user_input})
 
        try:
            # Get AI response
            response = chat(messages)
            print(f"\nAssistant: {response}\n")
 
            # Add assistant response to history
            messages.append({"role": "assistant", "content": response})
 
        except requests.exceptions.RequestException as e:
            print(f"Error: {e}")
 
if __name__ == "__main__":
    main()

Step 3: Run the Chatbot

export ELYXIR_API_KEY="elyxir_your_api_key"
python chatbot.py

Enhancing the Chatbot

Add Error Handling

def chat(messages, max_retries=3):
    """Send messages with retry logic."""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
 
    payload = {
        "model": "gpt-4o-mini",
        "messages": messages,
        "temperature": 0.7
    }
 
    for attempt in range(max_retries):
        try:
            response = requests.post(
                API_URL,
                headers=headers,
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            return response.json()["choices"][0]["message"]["content"]
 
        except requests.exceptions.HTTPError as e:
            if e.response.status_code == 429:
                # Rate limited, wait and retry
                import time
                time.sleep(2 ** attempt)
                continue
            raise
 
    raise Exception("Max retries exceeded")

Add Streaming

For real-time responses:

def chat_stream(messages):
    """Stream responses for real-time output."""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
 
    payload = {
        "model": "gpt-4o-mini",
        "messages": messages,
        "stream": True
    }
 
    response = requests.post(
        API_URL,
        headers=headers,
        json=payload,
        stream=True
    )
 
    full_response = ""
    for line in response.iter_lines():
        if line:
            line = line.decode("utf-8")
            if line.startswith("data: "):
                data = line[6:]
                if data != "[DONE]":
                    import json
                    chunk = json.loads(data)
                    if "choices" in chunk:
                        delta = chunk["choices"][0].get("delta", {})
                        content = delta.get("content", "")
                        print(content, end="", flush=True)
                        full_response += content
 
    print()  # New line after streaming
    return full_response

Add Conversation Memory Limit

Prevent token overflow:

def trim_messages(messages, max_messages=20):
    """Keep conversation history manageable."""
    if len(messages) > max_messages:
        # Keep system message + recent messages
        system_msg = messages[0] if messages[0]["role"] == "system" else None
        recent = messages[-(max_messages - 1):]
        if system_msg:
            return [system_msg] + recent
        return recent
    return messages

Complete Example

Full chatbot.py:

import os
import json
import time
import requests
 
API_KEY = os.environ.get("ELYXIR_API_KEY")
API_URL = "https://api.elyxir.ai/v1/chat/completions"
 
def chat(messages, max_retries=3):
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
 
    payload = {
        "model": "gpt-4o-mini",
        "messages": messages,
        "temperature": 0.7,
        "max_tokens": 500
    }
 
    for attempt in range(max_retries):
        try:
            response = requests.post(
                API_URL,
                headers=headers,
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            return response.json()["choices"][0]["message"]["content"]
        except requests.exceptions.HTTPError as e:
            if e.response.status_code == 429 and attempt < max_retries - 1:
                time.sleep(2 ** attempt)
                continue
            raise
 
    raise Exception("Max retries exceeded")
 
def trim_messages(messages, max_messages=20):
    if len(messages) > max_messages:
        system_msg = messages[0] if messages[0]["role"] == "system" else None
        recent = messages[-(max_messages - 1):]
        return [system_msg] + recent if system_msg else recent
    return messages
 
def main():
    print("Chatbot ready! Type 'quit' to exit.\n")
 
    messages = [
        {
            "role": "system",
            "content": "You are a helpful assistant. Be concise and friendly."
        }
    ]
 
    while True:
        user_input = input("You: ").strip()
 
        if user_input.lower() == "quit":
            print("Goodbye!")
            break
 
        if not user_input:
            continue
 
        messages.append({"role": "user", "content": user_input})
        messages = trim_messages(messages)
 
        try:
            response = chat(messages)
            print(f"\nAssistant: {response}\n")
            messages.append({"role": "assistant", "content": response})
        except Exception as e:
            print(f"Error: {e}")
 
if __name__ == "__main__":
    main()

Next Steps

Add web interface with Flask or FastAPI
Implement conversation persistence
Add specialized system prompts
Integrate with your application

API Reference - Full API documentation
Chat Completions - Endpoint details
Error Handling - Handle errors

Memory Supported Models