LucidQuery AI API Documentation

Complete reference for integrating with our advanced AI models via a unified API

Introduction

Welcome to the official documentation for the LucidQuery AI API. This unified API provides access to our suite of advanced AI models, each optimized for different use cases while maintaining a consistent, OpenAI-compatible interface.

Our API supports multiple state-of-the-art models through a single endpoint, allowing you to choose the best model for your specific needs without changing your integration code. Whether you need advanced reasoning capabilities or specialized coding assistance, we have you covered.

Available Models

Choose the right model for your use case. Each model is optimized for different scenarios while maintaining the same API interface.

Core Features

Our unified API provides consistent access to specialized AI capabilities:

Getting Started

To begin using the LucidQuery AI API, follow these simple steps:

1. Create an account on the LucidQuery platform if you don't already have one.
2. Generate an API key from the API management page in your dashboard.
3. Install the client library for your preferred programming language, or use standard HTTP request libraries.
4. Make your first API call following the examples in this documentation.

Authentication

All requests to the LucidQuery AI API require authentication using an API key. Your API key should be included in the HTTP headers of each request.

Add your API key to requests using the Authorization header:

Authorization: Bearer YOUR_API_KEY

API Endpoints

{
  "model": "lucidnova-rf1-100b",
  "messages": [
    {
      "role": "user",
      "content": "Hello World!"
    }
  ],
  "stream": false
}

In this example, the system will process the query and respond appropriately. Our AI models automatically adjust their internal parameters based on the query context, providing an optimal response without requiring any special configuration.

Request Parameters

The API accepts the following parameters in your request:

Response Format

The API returns responses in JSON format, with a structure similar to other AI APIs for easy integration:

Standard Response (Non-Streaming)

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1681841142,
  "model": "lucidnova-rf1-100b",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "\nAnalyzing the greeting 'Hello World!'...\nThis is a simple greeting that doesn't require any specialized knowledge or real-time information.\nI'll respond with an appropriate friendly greeting.\n\n\nHello! How can I assist you today? I'm here to help with a wide range of tasks. Feel free to ask me anything!"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 74,
    "total_tokens": 84
  }
}

Streaming Response

When using streaming mode (stream: true), the API will send partial responses as they are generated, following the same format as OpenAI's streaming API:

data: {"id":"chatcmpl-abc123","object":"chat.completion.chunk","created":1681841142,"model":"lucidnova-rf1-100b","choices":[{"delta":{"content":""},"index":0,"finish_reason":null}]}

data: {"id":"chatcmpl-abc123","object":"chat.completion.chunk","created":1681841142,"model":"lucidnova-rf1-100b","choices":[{"delta":{"content":"Analyzing the greeting 'Hello World!'..."},"index":0,"finish_reason":null}]}

... more chunks ...

data: [DONE]

Standard Request Examples

Below are examples of how to make standard (non-streaming) requests to the LucidQuery AI API in various programming languages:

# Using the OpenAI Python client library
from openai import OpenAI

# Initialize the client with your API key and base URL
client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://lucidquery.com/api/v1/chat/completions"
)

# Example 1: General reasoning task
response = client.chat.completions.create(
    model="lucidnova-rf1-100b",
    messages=[
        {"role": "user", "content": "Explain quantum computing in simple terms"}
    ]
)

# Example 2: Coding task
response = client.chat.completions.create(
    model="lucidquery-nexus-coder",
    messages=[
        {"role": "user", "content": "Write a Python function to calculate fibonacci numbers"}
    ]
)

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

// Using Node.js with the OpenAI npm package
import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://lucidquery.com/api/v1/chat/completions'
});

async function main() {
  // Example 1: General reasoning task
  const reasoning = await openai.chat.completions.create({
    model: 'lucidnova-rf1-100b',
    messages: [
      { role: 'user', content: 'Explain quantum computing in simple terms' }
    ]
  });
  
  // Example 2: Coding task
  const coding = await openai.chat.completions.create({
    model: 'lucidquery-nexus-coder',
    messages: [
      { role: 'user', content: 'Write a Python function to calculate fibonacci numbers' }
    ]
  });
  
  console.log(reasoning.choices[0].message.content);
}

main();

# Example 1: General reasoning task
curl -X POST https://lucidquery.com/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "lucidnova-rf1-100b",
    "messages": [
      {
        "role": "user",
        "content": "Explain quantum computing in simple terms"
      }
    ]
  }'

# Example 2: Coding task
curl -X POST https://lucidquery.com/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "lucidquery-nexus-coder",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function to calculate fibonacci numbers"
      }
    ]
  }'

Streaming Request Examples

Below are examples of how to make streaming requests to the LucidQuery AI API in various programming languages. Streaming provides a better user experience for longer responses as content appears progressively:

# Using the OpenAI Python client library
from openai import OpenAI

# Initialize the client with your API key and base URL
client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://lucidquery.com/api/v1/chat/completions"
)

# Streaming example
stream = client.chat.completions.create(
    model="lucidnova-rf1-100b",
    messages=[
        {"role": "user", "content": "Hello World!"}
    ],
    stream=True
)

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

// Using Node.js with the OpenAI npm package
import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://lucidquery.com/api/v1/chat/completions'
});

async function main() {
  // Streaming example
  const stream = await openai.chat.completions.create({
    model: 'lucidnova-rf1-100b',
    messages: [
      { role: 'user', content: 'Hello World!' }
    ],
    stream: true
  });
  
  for await (const chunk of stream) {
    if (chunk.choices[0]?.delta?.content) {
      process.stdout.write(chunk.choices[0].delta.content);
    }
  }
}

main();

# Streaming request
curl -X POST https://lucidquery.com/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  --no-buffer \
  -d '{
    "model": "lucidnova-rf1-100b",
    "messages": [
      {
        "role": "user",
        "content": "Hello World!"
      }
    ],
    "stream": true
  }'

Pricing

The LucidQuery AI API uses a unified token-based pricing model for all models. Tokens are the basic text units processed by our AI (roughly 4 characters or 0.75 words in English). We charge different rates for input and output tokens:

Rate Limits

To ensure system stability and fair resource allocation, the LucidQuery AI API implements the following rate limits across all models:

If you exceed these limits, the API will return a 429 error with a message indicating which limit was reached. Enterprise customers can request higher rate limits.

Error Handling

The API uses standard HTTP status codes and returns detailed error messages:

Error response example:

{
  "error": {
    "message": "Token rate limit exceeded. Maximum 1000000 tokens per minute.",
    "type": "rate_limit_exceeded",
    "param": null,
    "code": "rate_limit_exceeded"
  }
}

Best Practices

Follow these recommendations to get the most out of the LucidQuery AI API:

1. Be Specific and Clear

   The more specific and clear your input, the better the response will be. While our AI models have strong contextual understanding, explicitly stating what you want often yields the best results.

2. Manage Token Usage

   Keep your inputs concise to conserve tokens. Remember that both input and output tokens count toward your usage limits. If you don't need the reasoning pathway in responses, you can strip out the <think> sections programmatically.

3. Use Streaming for Long Responses

   For queries that might generate lengthy responses, use streaming to provide a better user experience with progressive content display.

4. Implement Retry Logic

   Implement exponential backoff retry logic for rate limit errors and transient server issues.

5. Leverage Conversation History

   For context-dependent tasks, include relevant previous messages in the conversation history to maintain context without repeating information.

Frequently Asked Questions

Our models feature innovative hybrid architectures. LucidNova RF1 combines diffusion-based reasoning with autoregressive generation for fast, transparent reasoning. LucidQuery Nexus Coder uses the reverse approach - autoregressive reasoning with diffusion generation - optimized for programming tasks. Both feature real-time capabilities and self-tuning parameters.

No. Unlike many other AI models, our models have real-time web access capabilities that allow them to retrieve current information when needed, without requiring explicit instructions to do so.

Our AI models feature self-tuning parameters that automatically adjust based on the query context. The system determines the optimal approach for each type of request without requiring manual parameter tuning.

Our AI models understand and can generate code in a wide range of programming languages, including but not limited to: Python, JavaScript, TypeScript, Java, C#, C++, PHP, Ruby, Go, Rust, Swift, Kotlin, and SQL. The LucidQuery Nexus Coder model is especially optimized for programming tasks.

Support

If you need assistance with our Inference API, you can contact our support team:

• Email Support: [email protected]

For Enterprise customers, please contact your dedicated account manager for priority support.