Developer documentation

$env:CODEFORGE_API_KEY = "YOUR_API_KEY"

export CODEFORGE_API_KEY="YOUR_API_KEY"

curl "https://codeforge-oaic.centralhubai.com/v1/models" -H "Authorization: Bearer $CODEFORGE_API_KEY"

{
  "model": "DeepSeek-V4.1-Flash",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ]
}

curl "https://codeforge-oaic.centralhubai.com/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $CODEFORGE_API_KEY" \
  --data-binary @request.json

import os
from openai import OpenAI

# pip install openai
client = OpenAI(api_key=os.environ["CODEFORGE_API_KEY"], base_url="https://codeforge-oaic.centralhubai.com/v1")
completion = client.chat.completions.create(
    model="DeepSeek-V4.1-Flash", messages=[{"role": "user", "content": "Hello!"}])
print(completion.choices[0].message.content)

import OpenAI from "openai";

// npm install openai
const client = new OpenAI({
  apiKey: process.env.CODEFORGE_API_KEY,
  baseURL: "https://codeforge-oaic.centralhubai.com/v1"
});

const completion = await client.chat.completions.create({
  model: "DeepSeek-V4.1-Flash", messages: [{ role: "user", content: "Hello!" }]
});
console.log(completion.choices[0].message.content);

{
  "id": "chatcmpl_example", "object": "chat.completion", "created": 1791417600,
  "model": "DeepSeek-V4.1-Flash",
  "choices": [{ "index": 0, "message": { "role": "assistant", "content": "Hello!" }, "finish_reason": "stop" }],
  "usage": { "prompt_tokens": 10, "completion_tokens": 4, "total_tokens": 14 }
}

import OpenAI from "openai";

// npm install openai
const client = new OpenAI({
  apiKey: process.env.CODEFORGE_API_KEY,
  baseURL: "https://codeforge-oaic.centralhubai.com/v1"
});

const stream = await client.chat.completions.create({
  model: "DeepSeek-V4.1-Flash", messages: [{ role: "user", content: "Hello!" }], stream: true
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

import OpenAI from "openai";

// npm install openai
const client = new OpenAI({
  apiKey: process.env.CODEFORGE_API_KEY,
  baseURL: "https://codeforge-oaic.centralhubai.com/v1"
});

const parameters = {
  type: "object", properties: { city: { type: "string" } },
  required: ["city"], additionalProperties: false
};
// Replace this example function with your own validated tool implementation.
const getWeather = ({ city }) => ({ city, temperature_c: 22 });

const tools = [{ type: "function", function: { name: "get_weather", description: "Get weather for a city", parameters } }];
const messages = [{ role: "user", content: "What is the weather in Cape Town?" }];
const first = await client.chat.completions.create({ model: "DeepSeek-V4.1-Flash", messages, tools });
const assistant = first.choices[0].message;
const calls = assistant.tool_calls ?? [];
if (calls.length) {
  const results = calls.map(call => {
    if (call.type !== "function" || call.function.name !== "get_weather") throw new Error("Unknown tool");
    return { role: "tool", tool_call_id: call.id, content: JSON.stringify(getWeather(JSON.parse(call.function.arguments))) };
  });
  const final = await client.chat.completions.create({ model: "DeepSeek-V4.1-Flash", tools, messages: [...messages, assistant, ...results] });
  console.log(final.choices[0].message.content);
} else console.log(assistant.content);

{
  "model": "DeepSeek-V4.1-Flash",
  "input": "Hello!"
}

curl "https://codeforge-oaic.centralhubai.com/v1/responses" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $CODEFORGE_API_KEY" \
  --data-binary @request.json

import os
from openai import OpenAI

# pip install openai
client = OpenAI(api_key=os.environ["CODEFORGE_API_KEY"], base_url="https://codeforge-oaic.centralhubai.com/v1")
response = client.responses.create(model="DeepSeek-V4.1-Flash", input="Hello!")
print(response.output_text)

import OpenAI from "openai";

// npm install openai
const client = new OpenAI({
  apiKey: process.env.CODEFORGE_API_KEY,
  baseURL: "https://codeforge-oaic.centralhubai.com/v1"
});

const response = await client.responses.create({ model: "DeepSeek-V4.1-Flash", input: "Hello!" });
console.log(response.output_text);

{
  "id": "resp_example", "object": "response", "created_at": 1791417600,
  "status": "completed", "model": "DeepSeek-V4.1-Flash",
  "output": [{
    "id": "msg_example", "type": "message", "role": "assistant", "status": "completed",
    "content": [{ "type": "output_text", "text": "Hello!", "annotations": [] }]
  }],
  "usage": { "input_tokens": 10, "output_tokens": 4, "total_tokens": 14 }
}

import OpenAI from "openai";

// npm install openai
const client = new OpenAI({
  apiKey: process.env.CODEFORGE_API_KEY,
  baseURL: "https://codeforge-oaic.centralhubai.com/v1"
});

const stream = await client.responses.create({ model: "DeepSeek-V4.1-Flash", input: "Hello!", stream: true });
for await (const event of stream) {
  if (event.type === "response.output_text.delta") process.stdout.write(event.delta);
}

import OpenAI from "openai";

// npm install openai
const client = new OpenAI({
  apiKey: process.env.CODEFORGE_API_KEY,
  baseURL: "https://codeforge-oaic.centralhubai.com/v1"
});

const parameters = {
  type: "object", properties: { city: { type: "string" } },
  required: ["city"], additionalProperties: false
};
// Replace this example function with your own validated tool implementation.
const getWeather = ({ city }) => ({ city, temperature_c: 22 });

const tools = [{ type: "function", name: "get_weather", description: "Get weather for a city", parameters, strict: true }];
const input = [{ role: "user", content: "What is the weather in Cape Town?" }];
const first = await client.responses.create({ model: "DeepSeek-V4.1-Flash", input, tools, store: false });
const calls = first.output.filter(item => item.type === "function_call");
if (calls.length) {
  const results = calls.map(call => {
    if (call.name !== "get_weather") throw new Error("Unknown tool");
    return { type: "function_call_output", call_id: call.call_id, output: JSON.stringify(getWeather(JSON.parse(call.arguments))) };
  });
  const final = await client.responses.create({
    model: "DeepSeek-V4.1-Flash", tools, store: false, input: [...input, ...first.output, ...results]
  });
  console.log(final.output_text);
} else console.log(first.output_text);

{
  "model": "DeepSeek-V4.1-Flash",
  "max_tokens": 256,
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ]
}

curl "https://codeforge-oaic.centralhubai.com/v1/messages" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $CODEFORGE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  --data-binary @request.json

import os
from anthropic import Anthropic

# pip install anthropic
client = Anthropic(api_key=os.environ["CODEFORGE_API_KEY"],
                   base_url="https://codeforge-oaic.centralhubai.com")
message = client.messages.create(
    model="DeepSeek-V4.1-Flash", max_tokens=256,
    messages=[{"role": "user", "content": "Hello!"}])
print("".join(block.text for block in message.content if block.type == "text"))

import Anthropic from "@anthropic-ai/sdk";

// npm install @anthropic-ai/sdk
const client = new Anthropic({
  apiKey: process.env.CODEFORGE_API_KEY,
  baseURL: "https://codeforge-oaic.centralhubai.com"
});

const message = await client.messages.create({
  model: "DeepSeek-V4.1-Flash", max_tokens: 256,
  messages: [{ role: "user", content: "Hello!" }]
});
console.log(message.content.filter(b => b.type === "text").map(b => b.text).join(""));

{
  "id": "msg_example", "type": "message", "role": "assistant",
  "model": "DeepSeek-V4.1-Flash", "content": [{ "type": "text", "text": "Hello!" }],
  "stop_reason": "end_turn", "stop_sequence": null,
  "usage": { "input_tokens": 10, "output_tokens": 4 }
}

import Anthropic from "@anthropic-ai/sdk";

// npm install @anthropic-ai/sdk
const client = new Anthropic({
  apiKey: process.env.CODEFORGE_API_KEY,
  baseURL: "https://codeforge-oaic.centralhubai.com"
});

const stream = await client.messages.create({
  model: "DeepSeek-V4.1-Flash", max_tokens: 256, stream: true,
  messages: [{ role: "user", content: "Hello!" }]
});
for await (const event of stream) {
  if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
    process.stdout.write(event.delta.text);
  }
}

import Anthropic from "@anthropic-ai/sdk";

// npm install @anthropic-ai/sdk
const client = new Anthropic({
  apiKey: process.env.CODEFORGE_API_KEY,
  baseURL: "https://codeforge-oaic.centralhubai.com"
});

const parameters = {
  type: "object", properties: { city: { type: "string" } },
  required: ["city"], additionalProperties: false
};
// Replace this example function with your own validated tool implementation.
const getWeather = ({ city }) => ({ city, temperature_c: 22 });

const tools = [{ name: "get_weather", description: "Get weather for a city", input_schema: parameters }];
const messages = [{ role: "user", content: "What is the weather in Cape Town?" }];
const first = await client.messages.create({ model: "DeepSeek-V4.1-Flash", max_tokens: 1024, tools, messages });
const calls = first.content.filter(b => b.type === "tool_use");
if (calls.length) {
  const results = calls.map(call => {
    if (call.name !== "get_weather") throw new Error("Unknown tool");
    return { type: "tool_result", tool_use_id: call.id, content: JSON.stringify(getWeather(call.input)) };
  });
  const final = await client.messages.create({
    model: "DeepSeek-V4.1-Flash", max_tokens: 1024, tools,
    messages: [...messages, { role: "assistant", content: first.content }, { role: "user", content: results }]
  });
  console.log(final.content);
} else console.log(first.content);

npm install -g opencode-ai

{
  "$schema": "https://opencode.ai/config.json",
  "model": "codeforge-oaic/DeepSeek-V4.1-Flash",
  "provider": {
    "codeforge-oaic": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Central Hub AI",
      "options": {
        "baseURL": "https://codeforge-oaic.centralhubai.com/v1",
        "apiKey": "{env:CODEFORGE_API_KEY}"
      },
      "models": {
        "DeepSeek-V4.1-Flash": {
          "name": "DeepSeek-V4.1-Flash (CH-AI)",
          "limit": {
            "context": 1000000,
            "input": 128000,
            "output": 384000
          },
          "reasoning": true,
          "variants": {
            "low": {
              "reasoningEffort": "low",
              "reasoningSummary": "auto",
              "textVerbosity": "medium"
            },
            "medium": {
              "reasoningEffort": "medium",
              "reasoningSummary": "auto",
              "textVerbosity": "medium"
            },
            "high": {
              "reasoningEffort": "high",
              "reasoningSummary": "detailed",
              "textVerbosity": "medium"
            },
            "max": {
              "reasoningEffort": "max",
              "reasoningSummary": "detailed",
              "textVerbosity": "medium"
            }
          }
        }
      }
    }
  }
}

npm install -g @openai/codex

Select a model compatible with Responses to generate Codex configuration.