OpenAI-compatible API

curl https://www.israelgpt.site/api/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "yahoobot-1",
    "messages": [
      { "role": "system", "content": "You are a concise coding assistant." },
      { "role": "user", "content": "Write a Python function that reverses a string." }
    ]
  }'

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ISRAELGPT_API_KEY,
  baseURL: "https://www.israelgpt.site/api/v1",
});

const stream = await client.chat.completions.create({
  model: "yahoobot-1",
  messages: [
    { role: "system", content: "You are a concise coding assistant." },
    { role: "user", content: "Write a Python function that reverses a string." },
  ],
  stream: true,
});

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

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://www.israelgpt.site/api/v1")

reply = client.chat.completions.create(
    model="yahoobot-1",
    messages=[
        {"role": "system", "content": "You are a concise coding assistant."},
        {"role": "user", "content": "Write a Python function that reverses a string."},
    ],
)
print(reply.choices[0].message.content)

The official OpenAI libraries work unchanged: set base_url / baseURL and the key. Without a base URL they talk to OpenAI, not to us.

GET /models lists both, with the prompt and reply sizes your key may use. It costs nothing against your limits, so a tool may call it as often as it likes (within a modest per-address allowance).

yahoobot-1 has no IsraelGPT personality or prompt. What it will and won't do comes from the model itself plus the checks below. israelbot-1 keeps IsraelGPT's personality and its rules, and because an OpenAI client can't carry IsraelGPT's signatures, earlier assistant messages are shown to it as quotes from your app rather than its own words (the same protection the native API gives). For long multi-turn chats, that makes yahoobot-1 the better fit.

Tool calling (OpenAI's tools, tool_choice and tool messages) works with yahoobot-1, streamed or not; israelbot-1 answers 400 tools_not_supported. Cline and Roo Code need none of it by default. The full round trip, every rule and every limit are on Tool calling.

The body is OpenAI’s. A field not listed here is ignored (every client sends a few). The listed ones behave like this:

supported: used as described. ignored: accepted so a client that always sends it keeps working; it has no effect. rejected: refused with a 400 that says what to send instead. This table and the code that checks requests are generated from one list, and a test fails if they disagree.

With temperature left out, replies use 0.6; with max_tokens left out, the reply is capped at 4,096 tokens or your plan’s limit if that is lower.

• Roles: system, developer (treated as system), user, assistant, tool. A conversation needs at least one message that isn’t a system message.
• content is a string, or an array of {"type":"text","text":"..."} parts, joined with newlines. Image, audio and file parts are refused (400 unsupported_content): text only.
• Control characters other than tab and newlines are removed, not refused, since terminal output is full of colour codes.
• All system and developer messages are joined into one system prompt on yahoobot-1, wherever they appear in the conversation. With none, a one-line default is used.
• On israelbot-1 the last message has to come from the user.
• Up to 100 messages on the free plan, 2,000 with a Pro plan.

{
  "id": "chatcmpl-8f2c1e4a9b3d7f01-TLV",
  "object": "chat.completion",
  "created": 1790000000,
  "model": "yahoobot-1",
  "choices": [{
    "index": 0,
    "message": { "role": "assistant", "content": "def reverse(s): return s[::-1]" },
    "finish_reason": "stop"
  }],
  "usage": { "prompt_tokens": 41, "completion_tokens": 12, "total_tokens": 53 }
}

usage is what the model counted. It is what counts against your daily tokens. Prompt and reply sizes, what is checked, every error, and what isn't offered are on Sizes, safety and errors.

Send "stream": true and the answer is server-sent events in OpenAI’s chunk format, ending with data: [DONE]. Add "stream_options": {"include_usage": true} to get a last chunk with the token counts (choices empty). Without it, no usage chunk is sent.

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

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","created":1790000000,"model":"yahoobot-1","choices":[{"index":0,"delta":{"content":"def"},"finish_reason":null}]}

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","created":1790000000,"model":"yahoobot-1","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","created":1790000000,"model":"yahoobot-1","choices":[],"usage":{"prompt_tokens":41,"completion_tokens":12,"total_tokens":53}}

data: [DONE]

• Lines starting with : are keep-alive comments. Every SSE client ignores them.
• yahoobot-1 is relayed as the model writes it, in small batches about ten times a second. If the service is ever under load it can switch to waiting for the whole reply and sending it as a stream of pieces (with keep-alive comments while it waits); the chunks are the same.
• israelbot-1 is finished first and then sent as a stream, so its reply can be checked as a whole.
• A failure before any text is an ordinary JSON error with its HTTP status (502, 429, 400...). A failure part-way sends data: {"error":{...}} and then [DONE], because the status line has already gone. The error has the same shape as every other.
• If you close the connection, the model is stopped. The tokens counted for that request are an estimate of what it had written by then.