Chat Completions API

MeteorAI provides a fully OpenAI-compatible chat interface. You can use the OpenAI SDK to directly call our services.

Basic Information

API Endpoint

https://api.routin.ai/v1/chat/completions

Authentication Add API Key in request header:

Authorization: Bearer YOUR_API_KEY

MeteorAI is fully compatible with OpenAI SDK. Simply modify the base_url parameter for seamless integration.

Request Parameters

Required Parameters

Parameter	Type	Description
`model`	string	Model name, e.g., `gpt-4o`, `claude-3-5-sonnet-20241022`
`messages`	array	Array of conversation messages

Optional Parameters

Parameter	Type	Default	Description
`temperature`	number	1	Sampling temperature (0-2)
`top_p`	number	1	Nucleus sampling parameter (0-1)
`max_tokens`	integer	-	Maximum number of tokens to generate
`stream`	boolean	false	Whether to use streaming output
`presence_penalty`	number	0	Presence penalty (-2.0 to 2.0)
`frequency_penalty`	number	0	Frequency penalty (-2.0 to 2.0)
`user`	string	-	User identifier

Messages Format

{
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful assistant."
    },
    {
      "role": "user",
      "content": "Hello!"
    }
  ]
}

Supported role values:

system: System message, defines assistant behavior
user: User message
assistant: Assistant response

Response Format

Standard Response

{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1677652288,
  "model": "gpt-4o",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! How can I help you today?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 9,
    "completion_tokens": 12,
    "total_tokens": 21
  }
}

Streaming Response

data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"role":"assistant","content":"Hello"},"finish_reason":null}]}

data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"content":"!"},"finish_reason":null}]}

data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: [DONE]

Code Examples

Basic Call

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.routin.ai/v1"
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello, please introduce yourself"}
    ],
    temperature=0.7,
    max_tokens=150
)

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

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.routin.ai/v1',
});

async function main() {
  const response = await client.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: 'You are a helpful assistant.' },
      { role: 'user', content: 'Hello, please introduce yourself' },
    ],
    temperature: 0.7,
    max_tokens: 150,
  });

  console.log(response.choices[0].message.content);
}

main();

const OpenAI = require('openai');

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.routin.ai/v1',
});

client.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'Hello, please introduce yourself' },
  ],
  temperature: 0.7,
  max_tokens: 150,
}).then(response => {
  console.log(response.choices[0].message.content);
});

using OpenAI.Chat;

var client = new ChatClient(
    model: "gpt-4o",
    apiKey: "YOUR_API_KEY",
    new OpenAIClientOptions
    {
        Endpoint = new Uri("https://api.routin.ai/v1")
    }
);

var messages = new List<ChatMessage>
{
    new SystemChatMessage("You are a helpful assistant."),
    new UserChatMessage("Hello, please introduce yourself")
};

var response = await client.CompleteChatAsync(
    messages,
    new ChatCompletionOptions
    {
        Temperature = 0.7f,
        MaxOutputTokenCount = 150
    }
);

Console.WriteLine(response.Value.Content[0].Text);

curl https://api.routin.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-4o",
    "messages": [
      {
        "role": "system",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "Hello, please introduce yourself"
      }
    ],
    "temperature": 0.7,
    "max_tokens": 150
  }'

Streaming Output

Streaming output allows real-time retrieval of model-generated content for better user experience.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.routin.ai/v1"
)

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Tell me an interesting story"}
    ],
    stream=True
)

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

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.routin.ai/v1',
});

async function main() {
  const stream = await client.chat.completions.create({
    model: 'gpt-4o',
    messages: [{ role: 'user', content: 'Tell me an interesting story' }],
    stream: true,
  });

  for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content;
    if (content) {
      process.stdout.write(content);
    }
  }
}

main();

const OpenAI = require('openai');

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.routin.ai/v1',
});

async function main() {
  const stream = await client.chat.completions.create({
    model: 'gpt-4o',
    messages: [{ role: 'user', content: 'Tell me an interesting story' }],
    stream: true,
  });

  for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content;
    if (content) {
      process.stdout.write(content);
    }
  }
}

main();

using OpenAI.Chat;

var client = new ChatClient(
    model: "gpt-4o",
    apiKey: "YOUR_API_KEY",
    new OpenAIClientOptions
    {
        Endpoint = new Uri("https://api.routin.ai/v1")
    }
);

var messages = new List<ChatMessage>
{
    new UserChatMessage("Tell me an interesting story")
};

await foreach (var update in client.CompleteChatStreamingAsync(messages))
{
    foreach (var contentPart in update.ContentUpdate)
    {
        Console.Write(contentPart.Text);
    }
}

curl https://api.routin.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-4o",
    "messages": [
      {
        "role": "user",
        "content": "Tell me an interesting story"
      }
    ],
    "stream": true
  }'

Multi-turn Conversation

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.routin.ai/v1"
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."}
]

# First turn
messages.append({"role": "user", "content": "My name is John"})
response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages
)
assistant_message = response.choices[0].message.content
messages.append({"role": "assistant", "content": assistant_message})
print(f"Assistant: {assistant_message}")

# Second turn
messages.append({"role": "user", "content": "What's my name?"})
response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages
)
assistant_message = response.choices[0].message.content
print(f"Assistant: {assistant_message}")

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.routin.ai/v1',
});

async function main() {
  const messages: OpenAI.Chat.ChatCompletionMessageParam[] = [
    { role: 'system', content: 'You are a helpful assistant.' },
  ];

  // First turn
  messages.push({ role: 'user', content: 'My name is John' });
  let response = await client.chat.completions.create({
    model: 'gpt-4o',
    messages,
  });
  let assistantMessage = response.choices[0].message.content;
  messages.push({ role: 'assistant', content: assistantMessage! });
  console.log(`Assistant: ${assistantMessage}`);

  // Second turn
  messages.push({ role: 'user', content: "What's my name?" });
  response = await client.chat.completions.create({
    model: 'gpt-4o',
    messages,
  });
  assistantMessage = response.choices[0].message.content;
  console.log(`Assistant: ${assistantMessage}`);
}

main();

using OpenAI.Chat;

var client = new ChatClient(
    model: "gpt-4o",
    apiKey: "YOUR_API_KEY",
    new OpenAIClientOptions
    {
        Endpoint = new Uri("https://api.routin.ai/v1")
    }
);

var messages = new List<ChatMessage>
{
    new SystemChatMessage("You are a helpful assistant.")
};

// First turn
messages.Add(new UserChatMessage("My name is John"));
var response = await client.CompleteChatAsync(messages);
var assistantMessage = response.Value.Content[0].Text;
messages.Add(new AssistantChatMessage(assistantMessage));
Console.WriteLine($"Assistant: {assistantMessage}");

// Second turn
messages.Add(new UserChatMessage("What's my name?"));
response = await client.CompleteChatAsync(messages);
assistantMessage = response.Value.Content[0].Text;
Console.WriteLine($"Assistant: {assistantMessage}");

Error Handling

Always add error handling in production to prevent application crashes from API failures.

from openai import OpenAI, APIError, RateLimitError, APIConnectionError

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.routin.ai/v1"
)

try:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Hello!"}]
    )
    print(response.choices[0].message.content)
except RateLimitError as e:
    print(f"Rate limit exceeded: {e}")
except APIConnectionError as e:
    print(f"Connection error: {e}")
except APIError as e:
    print(f"API error: {e}")
except Exception as e:
    print(f"Unknown error: {e}")

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.routin.ai/v1',
});

async function main() {
  try {
    const response = await client.chat.completions.create({
      model: 'gpt-4o',
      messages: [{ role: 'user', content: 'Hello!' }],
    });
    console.log(response.choices[0].message.content);
  } catch (error) {
    if (error instanceof OpenAI.APIError) {
      console.error(`API error [${error.status}]: ${error.message}`);
    } else if (error instanceof OpenAI.RateLimitError) {
      console.error('Rate limit exceeded');
    } else {
      console.error('Unknown error:', error);
    }
  }
}

main();

using OpenAI.Chat;
using OpenAI;

var client = new ChatClient(
    model: "gpt-4o",
    apiKey: "YOUR_API_KEY",
    new OpenAIClientOptions
    {
        Endpoint = new Uri("https://api.routin.ai/v1")
    }
);

try
{
    var response = await client.CompleteChatAsync(
        new List<ChatMessage>
        {
            new UserChatMessage("Hello!")
        }
    );
    Console.WriteLine(response.Value.Content[0].Text);
}
catch (ClientResultException ex) when (ex.Status == 429)
{
    Console.WriteLine($"Rate limit exceeded: {ex.Message}");
}
catch (ClientResultException ex)
{
    Console.WriteLine($"API error [{ex.Status}]: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Unknown error: {ex.Message}");
}

Common Error Codes

Code	Description	Solution
401	Invalid or missing API Key	Check Authorization header
429	Rate limit exceeded	Reduce request frequency or upgrade quota
400	Invalid request parameters	Check request parameter format
500	Internal server error	Retry later or contact support
503	Service temporarily unavailable	Retry later

Supported Models

MeteorAI supports models from multiple AI providers:

OpenAI: gpt-4o, gpt-4o-mini, gpt-4-turbo, gpt-3.5-turbo
Anthropic: claude-3-5-sonnet-20241022, claude-3-5-haiku-20241022, claude-3-opus-20240229
Google: gemini-2.0-flash-exp, gemini-1.5-pro, gemini-1.5-flash
Others: Check admin panel for complete model list

Different models have different pricing and performance. Choose the appropriate model based on your needs.

Best Practices

Use system messages: Define assistant behavior via system role
Control token count: Use max_tokens to control generation length and costs
Error retry: Implement exponential backoff for temporary errors
Streaming output: Use stream=true for long text generation
Save conversation history: Include complete conversation history in messages array for multi-turn conversations
Monitor usage: Regularly check admin panel statistics to optimize API usage

More Resources

Embeddings API - Text vectorization interface
Images API - Image generation interface
Audio API - Speech recognition and synthesis interface
Model List - View all supported models

Chat Completions API

On this page