مستندات درگاه هوش مصنوعی پنزی

export PENZY_API_KEY="sk-pz-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

curl https://ai.penzy.net/v1/chat/completions \
  -H "Authorization: Bearer $PENZY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o-mini",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "پایتخت ایران کجاست؟"}
    ]
  }'

# pip install openai
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://ai.penzy.net/v1",
    api_key=os.environ["PENZY_API_KEY"],
)

resp = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "پایتخت ایران کجاست؟"},
    ],
)
print(resp.choices[0].message.content)

// npm install openai
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://ai.penzy.net/v1",
  apiKey: process.env.PENZY_API_KEY,
});

const resp = await client.chat.completions.create({
  model: "openai/gpt-4o-mini",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "پایتخت ایران کجاست؟" },
  ],
});
console.log(resp.choices[0].message.content);

resp = client.chat.completions.create(
    model="anthropic/claude-sonnet-4-5",          # Claude
    # model="openrouter/google/gemini-2.5-flash", # Gemini via OpenRouter
    # model="openrouter/deepseek/deepseek-chat",  # DeepSeek via OpenRouter
    messages=[{"role": "user", "content": "Hello!"}],
)

{
  "id": "chatcmpl-9f2c...",
  "object": "chat.completion",
  "created": 1762950000,
  "model": "openai/gpt-4o-mini",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "پایتخت ایران تهران است." },
      "finish_reason": "stop"
    }
  ],
  "usage": { "prompt_tokens": 24, "completion_tokens": 9, "total_tokens": 33 }
}

POST /v1/chat/completions HTTP/1.1
Host: ai.penzy.net
Authorization: Bearer sk-pz-xxxxxxxxxxxxxxxx
Content-Type: application/json

messages = [{"role": "system", "content": "تو یک دستیار برنامه‌نویسی هستی."}]

while True:
    user = input("you: ")
    messages.append({"role": "user", "content": user})
    r = client.chat.completions.create(model="anthropic/claude-sonnet-4-5", messages=messages)
    answer = r.choices[0].message.content
    messages.append({"role": "assistant", "content": answer})
    print("ai:", answer)

stream = client.chat.completions.create(
    model="anthropic/claude-sonnet-4-5",
    messages=[{"role": "user", "content": "یک داستان کوتاه بنویس"}],
    stream=True,
    stream_options={"include_usage": True},
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n\ntokens:", chunk.usage.total_tokens)

const stream = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-4-5",
  messages: [{ role: "user", content: "یک داستان کوتاه بنویس" }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

curl -N https://ai.penzy.net/v1/chat/completions \
  -H "Authorization: Bearer $PENZY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"openai/gpt-4o-mini","stream":true,
       "messages":[{"role":"user","content":"Count to 5"}]}'

// فقط در محیط سرور یا با کلید محدود استفاده کنید
const res = await fetch("https://ai.penzy.net/v1/chat/completions", {
  method: "POST",
  headers: { "Authorization": `Bearer ${KEY}`, "Content-Type": "application/json" },
  body: JSON.stringify({ model: "openai/gpt-4o-mini", stream: true,
    messages: [{ role: "user", content: "Hi" }] }),
});
const reader = res.body.getReader();
const dec = new TextDecoder();
let buf = "";
while (true) {
  const { value, done } = await reader.read();
  if (done) break;
  buf += dec.decode(value, { stream: true });
  const lines = buf.split("\n"); buf = lines.pop();
  for (const line of lines) {
    if (!line.startsWith("data: ") || line === "data: [DONE]") continue;
    const delta = JSON.parse(line.slice(6)).choices[0]?.delta?.content;
    if (delta) output.textContent += delta;
  }
}

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

data: {"id":"chatcmpl-…","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"سلام"}}]}

data: {"id":"chatcmpl-…","object":"chat.completion.chunk","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: [DONE]

import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

messages = [{"role": "user", "content": "هوای تهران چطوره؟"}]
r = client.chat.completions.create(model="anthropic/claude-sonnet-4-5",
                                   messages=messages, tools=tools)
msg = r.choices[0].message

if msg.tool_calls:
    messages.append(msg)  # assistant message with tool_calls
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = {"city": args["city"], "temp_c": 18, "sky": "clear"}  # your code
        messages.append({"role": "tool", "tool_call_id": call.id,
                         "content": json.dumps(result)})
    final = client.chat.completions.create(model="anthropic/claude-sonnet-4-5",
                                           messages=messages, tools=tools)
    print(final.choices[0].message.content)

const tools = [{
  type: "function",
  function: {
    name: "get_weather",
    description: "Get current weather for a city",
    parameters: { type: "object", properties: { city: { type: "string" } }, required: ["city"] },
  },
}];

const messages = [{ role: "user", content: "هوای تهران چطوره؟" }];
const r = await client.chat.completions.create({ model: "openai/gpt-4o", messages, tools });
const msg = r.choices[0].message;

if (msg.tool_calls) {
  messages.push(msg);
  for (const call of msg.tool_calls) {
    const args = JSON.parse(call.function.arguments);
    messages.push({ role: "tool", tool_call_id: call.id,
      content: JSON.stringify({ city: args.city, temp_c: 18 }) });
  }
  const final = await client.chat.completions.create({ model: "openai/gpt-4o", messages, tools });
  console.log(final.choices[0].message.content);
}

import base64

with open("invoice.png", "rb") as f:
    b64 = base64.b64encode(f.read()).decode()

r = client.chat.completions.create(
    model="anthropic/claude-sonnet-4-5",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "مبلغ کل این فاکتور چقدر است؟"},
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}},
            # or: {"type": "image_url", "image_url": {"url": "https://example.com/a.jpg"}}
        ],
    }],
)

r = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Extract: Ali Rezaei, 32, Tehran"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                    "city": {"type": "string"},
                },
                "required": ["name", "age", "city"],
                "additionalProperties": False,
            },
        },
    },
)
print(r.choices[0].message.content)  # {"name":"Ali Rezaei","age":32,"city":"Tehran"}

r = client.chat.completions.create(
    model="anthropic/claude-sonnet-4-5",
    messages=[{"role": "user", "content": "اثبات کن جذر ۲ گنگ است."}],
    reasoning_effort="medium",          # low | medium | high
    # extra_body={"thinking": {"type": "enabled", "budget_tokens": 10000}},
)
print(r.choices[0].message.content)

curl https://ai.penzy.net/v1/messages \
  -H "x-api-key: $PENZY_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello, Claude"}]
  }'

# pip install anthropic
import anthropic

client = anthropic.Anthropic(
    base_url="https://ai.penzy.net",   # بدون /v1 — SDK خودش اضافه می‌کند
    api_key="sk-pz-...",
)
msg = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
)
print(msg.content[0].text)

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

const client = new Anthropic({ baseURL: "https://ai.penzy.net", apiKey: process.env.PENZY_API_KEY });
const msg = await client.messages.create({
  model: "claude-sonnet-4-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
});
console.log(msg.content[0].text);

r = client.responses.create(
    model="openai/gpt-4o-mini",
    input="سه نکته برای نوشتن کد تمیز بگو",
)
print(r.output_text)

e = client.embeddings.create(
    model="openai/text-embedding-3-small",
    input=["سلام دنیا", "Hello world"],
)
print(len(e.data[0].embedding))  # 1536

curl https://ai.penzy.net/v1/embeddings \
  -H "Authorization: Bearer $PENZY_API_KEY" -H "Content-Type: application/json" \
  -d '{"model":"openai/text-embedding-3-small","input":"سلام دنیا"}'

img = client.images.generate(
    model="openai/gpt-image-1",
    prompt="A Persian garden at sunset, watercolor",
    size="1024x1024",
)
import base64; open("out.png", "wb").write(base64.b64decode(img.data[0].b64_json))

curl https://ai.penzy.net/v1/models -H "Authorization: Bearer $PENZY_API_KEY"

for m in client.models.list():
    print(m.id)

{
  "object": "list",
  "data": [
    {
      "id": "anthropic/claude-sonnet-4-5-20250929",
      "object": "model",
      "owned_by": "anthropic",
      "name": "Claude Sonnet 4.5",
      "context_length": 1000000,
      "pricing": { "input_per_million": 3, "output_per_million": 15, "currency": "USD" }
    }
  ]
}

curl https://ai.penzy.net/v1/me -H "Authorization: Bearer $PENZY_API_KEY"

{
  "key": { "name": "backend-prod", "prefix": "sk-pz-AbCd…wxyz", "owner": "Team A", "rpm_limit": 60, "allowed_models": "*" },
  "budget": { "limit_usd": 50, "period": "monthly", "spent_usd": 12.41, "remaining_usd": 37.59 },
  "totals": { "requests": 1840, "prompt_tokens": 2210400, "completion_tokens": 512330, "cost_usd": 31.07 },
  "last_30_days": { "by_model": [ … ], "daily": [ … ] },
  "recent": [ … ]
}

pip install openai
export OPENAI_BASE_URL="https://ai.penzy.net/v1"
export OPENAI_API_KEY="sk-pz-..."

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI()  # reads OPENAI_BASE_URL / OPENAI_API_KEY

async def ask(model, q):
    r = await client.chat.completions.create(model=model, messages=[{"role": "user", "content": q}])
    return model, r.choices[0].message.content

async def main():
    models = ["openai/gpt-4o-mini", "anthropic/claude-haiku-4-5", "openrouter/google/gemini-2.5-flash"]
    for model, answer in await asyncio.gather(*(ask(m, "یک جمله درباره ایران") for m in models)):
        print(f"[{model}] {answer}\n")

asyncio.run(main())

import requests

r = requests.post(
    "https://ai.penzy.net/v1/chat/completions",
    headers={"Authorization": "Bearer sk-pz-..."},
    json={"model": "openai/gpt-4o-mini", "messages": [{"role": "user", "content": "Hi"}]},
    timeout=120,
)
r.raise_for_status()
print(r.json()["choices"][0]["message"]["content"])

import OpenAI from "openai";

export const ai = new OpenAI({
  baseURL: "https://ai.penzy.net/v1",
  apiKey: process.env.PENZY_API_KEY!,
  timeout: 120_000,
  maxRetries: 2,
});

const r = await ai.chat.completions.create({
  model: "openrouter/deepseek/deepseek-chat",
  messages: [{ role: "user", content: "Explain closures in JS" }],
});
console.log(r.choices[0].message.content);

const r = await fetch("https://ai.penzy.net/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.PENZY_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "anthropic/claude-haiku-4-5",
    messages: [{ role: "user", content: "Hi" }],
  }),
});
const data = await r.json();
console.log(data.choices[0].message.content);

<?php
$ch = curl_init("https://ai.penzy.net/v1/chat/completions");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer " . getenv("PENZY_API_KEY"),
        "Content-Type: application/json",
    ],
    CURLOPT_POSTFIELDS => json_encode([
        "model" => "openai/gpt-4o-mini",
        "messages" => [["role" => "user", "content" => "سلام"]],
    ]),
]);
$res = json_decode(curl_exec($ch), true);
echo $res["choices"][0]["message"]["content"];

use Illuminate\Support\Facades\Http;

$res = Http::withToken(env('PENZY_API_KEY'))
    ->timeout(120)
    ->post('https://ai.penzy.net/v1/chat/completions', [
        'model' => 'anthropic/claude-sonnet-4-5',
        'messages' => [['role' => 'user', 'content' => 'سلام']],
    ])->throw()->json();

return $res['choices'][0]['message']['content'];

// composer require openai-php/client
$client = OpenAI::factory()
    ->withBaseUri('https://ai.penzy.net/v1')
    ->withApiKey(getenv('PENZY_API_KEY'))
    ->make();

$r = $client->chat()->create([
    'model' => 'openai/gpt-4o-mini',
    'messages' => [['role' => 'user', 'content' => 'Hello']],
]);
echo $r->choices[0]->message->content;

export ANTHROPIC_BASE_URL="https://ai.penzy.net"
export ANTHROPIC_API_KEY="sk-pz-..."

# pip install langchain-openai
from langchain_openai import ChatOpenAI, OpenAIEmbeddings

llm = ChatOpenAI(
    base_url="https://ai.penzy.net/v1",
    api_key="sk-pz-...",
    model="anthropic/claude-sonnet-4-5",
    temperature=0.3,
)
print(llm.invoke("What is RAG?").content)

emb = OpenAIEmbeddings(base_url="https://ai.penzy.net/v1", api_key="sk-pz-...",
                       model="openai/text-embedding-3-small")

import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "openai/gpt-4o-mini",
  apiKey: process.env.PENZY_API_KEY,
  configuration: { baseURL: "https://ai.penzy.net/v1" },
});
const res = await llm.invoke("What is RAG?");

// npm install ai @ai-sdk/openai-compatible
import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { streamText } from "ai";

const penzy = createOpenAICompatible({
  name: "penzy",
  baseURL: "https://ai.penzy.net/v1",
  apiKey: process.env.PENZY_API_KEY,
  includeUsage: true,
});

const result = streamText({
  model: penzy("anthropic/claude-sonnet-4-5"),
  prompt: "Write a haiku about Tehran",
});
for await (const text of result.textStream) process.stdout.write(text);

export ANTHROPIC_BASE_URL="https://ai.penzy.net"
export ANTHROPIC_AUTH_TOKEN="sk-pz-..."
# اختیاری: انتخاب مدل
export ANTHROPIC_MODEL="claude-sonnet-4-5"
claude

// ~/.claude/settings.json
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://ai.penzy.net",
    "ANTHROPIC_AUTH_TOKEN": "sk-pz-..."
  }
}

models:
  - name: Claude via Penzy
    provider: openai
    model: anthropic/claude-sonnet-4-5
    apiBase: https://ai.penzy.net/v1
    apiKey: sk-pz-...
  - name: GPT-4o via Penzy
    provider: openai
    model: openai/gpt-4o
    apiBase: https://ai.penzy.net/v1
    apiKey: sk-pz-...

{
  "error": {
    "message": "Budget exhausted for this key ($50.0012 of $50 – monthly).",
    "type": "insufficient_quota",
    "code": "budget_exceeded"
  }
}