API Documentation & Architecture Reference

curl https://api.genforai.fun/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer gfa_live_your_approved_key" \
  -d '{
    "model": "gpt-5.6-sol",
    "messages": [
      {"role": "user", "content": "Explain closures in JavaScript in 2 concise sentences."}
    ],
    "temperature": 0.7
  }'

from openai import OpenAI

# Initialize standard OpenAI client pointing to GenForAi gateway
client = OpenAI(
    base_url="https://api.genforai.fun/v1",
    api_key="gfa_live_your_approved_key"
)

completion = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[
        {"role": "user", "content": "Explain closures in JavaScript in 2 concise sentences."}
    ],
    temperature=0.7
)

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

import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: 'https://api.genforai.fun/v1',
  apiKey: 'gfa_live_your_approved_key',
});

const completion = await openai.chat.completions.create({
  model: 'gpt-5.6-sol',
  messages: [{ role: 'user', content: 'Explain closures in JavaScript in 2 concise sentences.' }],
});

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

curl -X POST https://api.genforai.fun/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer gfa_live_your_approved_key" \
  -d '{
    "model": "gpt-5.6-sol",
    "messages": [
      {"role": "system", "content": "You are a senior systems engineer."},
      {"role": "user", "content": "How do goroutines differ from OS threads?"}
    ],
    "temperature": 0.7,
    "stream": false
  }'

from openai import OpenAI

client = OpenAI(
    base_url="https://api.genforai.fun/v1",
    api_key="gfa_live_your_approved_key"
)

response = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[
        {"role": "system", "content": "You are a senior systems engineer."},
        {"role": "user", "content": "How do goroutines differ from OS threads?"}
    ],
    temperature=0.7,
    stream=False
)

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

import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: 'https://api.genforai.fun/v1',
  apiKey: 'gfa_live_your_approved_key',
});

const response = await openai.chat.completions.create({
  model: 'gpt-5.6-sol',
  messages: [
    { role: 'system', content: 'You are a senior systems engineer.' },
    { role: 'user', content: 'How do goroutines differ from OS threads?' }
  ],
  temperature: 0.7,
});

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

<?php
$payload = [
    'model' => 'gpt-5.6-sol',
    'messages' => [
        ['role' => 'user', 'content' => 'How do goroutines differ from OS threads?']
    ],
    'temperature' => 0.7
];

$ch = curl_init('https://api.genforai.fun/v1/chat/completions');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Content-Type: application/json',
        'Authorization: Bearer gfa_live_your_approved_key'
    ],
    CURLOPT_POSTFIELDS => json_encode($payload),
    CURLOPT_RETURNTRANSFER => true
]);

$response = curl_exec($ch);
curl_close($ch);
echo $response;

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    payload := map[string]interface{}{
        "model": "gpt-5.6-sol",
        "messages": []map[string]string{
            {"role": "user", "content": "How do goroutines differ from OS threads?"},
        },
    }
    jsonBytes, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://api.genforai.fun/v1/chat/completions", bytes.NewBuffer(jsonBytes))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer gfa_live_your_approved_key")

    resp, err := http.DefaultClient.Do(req)
    if err != nil { panic(err) }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

{
  "id": "chatcmpl-9f8a2b1c4e7d",
  "object": "chat.completion",
  "created": 1792896500,
  "model": "gpt-5.6-sol",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Goroutines are lightweight user-space threads managed cooperatively by Go's runtime, whereas OS threads are heavier kernel-managed execution units.",
        "reasoning_content": "The user requested key differences. I need to contrast user-space vs kernel space, memory footprints, and scheduling overhead."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 24,
    "completion_tokens": 38,
    "total_tokens": 62,
    "completion_tokens_details": {
      "reasoning_tokens": 28
    }
  }
}

curl https://api.genforai.fun/v1/models \
  -H "Authorization: Bearer gfa_live_your_approved_key"

curl https://api.genforai.fun/v1/models/gpt-5.6-sol \
  -H "Authorization: Bearer gfa_live_your_approved_key"

{
  "status": "operational",
  "service": "GenForAi",
  "version": "1.0.0",
  "environment": "production",
  "database": "connected",
  "database_driver": "mysql",
  "active_models": 3,
  "timestamp": 1794050485
}

data: {"id":"chatcmpl-a1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

# Reasoning stream chunk
data: {"id":"chatcmpl-a1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"reasoning_content":"Step 1: Compute time complexity...\n"},"finish_reason":null}]}

# Final content stream chunk
data: {"id":"chatcmpl-a1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"The algorithm runs in O(N log N) time."},"finish_reason":null}]}

# Terminal signal
data: [DONE]

from openai import OpenAI

# Initialize client pointing to GenForAi
client = OpenAI(
    base_url="https://api.genforai.fun/v1",
    api_key="gfa_live_your_approved_key"
)

stream = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Stream a short haiku about compilers."}],
    stream=True
)

for chunk in stream:
    text = chunk.choices[0].delta.content or ""
    print(text, end="", flush=True)

import asyncio
from openai import AsyncOpenAI

async def main():
    client = AsyncOpenAI(
        base_url="https://api.genforai.fun/v1",
        api_key="gfa_live_your_approved_key"
    )
    res = await client.chat.completions.create(
        model="gpt-5.6-sol",
        messages=[{"role": "user", "content": "Explain LRU cache."}]
    )
    print(res.choices[0].message.content)

asyncio.run(main())

import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: 'https://api.genforai.fun/v1',
  apiKey: 'gfa_live_your_approved_key',
});

const stream = await openai.chat.completions.create({
  model: 'gpt-5.6-sol',
  messages: [{ role: 'user', content: 'Explain asynchronous event loops.' }],
  stream: true,
});

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

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-5.6-sol",
    openai_api_base="https://api.genforai.fun/v1",
    openai_api_key="gfa_live_your_approved_key",
    temperature=0.7
)

response = llm.invoke("Explain quantum entanglement.")
print(response.content)

# litellm config.yaml
model_list:
  - model_name: custom-model
    litellm_params:
      model: openai/gpt-5.6-sol      api_base: https://api.genforai.fun/v1      api_key: gfa_live_your_approved_key

curl -X POST https://api.genforai.fun/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer gfa_live_your_approved_key" \
  -d '{
    "model": "gpt-5.6-sol",
    "messages": [{"role": "user", "content": "Ping"}],
    "temperature": 0.7
  }'