أكواد استدعاء APIs الذكاء الاصطناعي، OpenAI، Anthropic، Google

كل نموذج AI رائد يوفّر API. المعرفة بها تفتح بناء تطبيقات ذكية. هذه أكواد جاهزة للثلاثة الكبار.

OpenAI API

Python

from openai import OpenAI
import os
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# محادثة أساسية
def ask_gpt(question: str, model: str = "gpt-5.6-luna") -> str:
    response = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": "أنت مساعد ذكي."},
            {"role": "user", "content": question}
        ]
    )
    return response.choices[0].message.content

# Streaming
def stream_gpt(question: str):
    stream = client.chat.completions.create(
        model="gpt-5.6",
        messages=[{"role": "user", "content": question}],
        stream=True
    )
    for chunk in stream:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)

# JSON structured
def extract_data(text: str) -> dict:
    import json
    response = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {"role": "system", "content": "استخرج JSON: {name, phone, email}"},
            {"role": "user", "content": text}
        ],
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)

# توليد صورة
def generate_image(prompt: str) -> str:
    response = client.images.generate(
        model="dall-e-3",
        prompt=prompt,
        size="1024x1024",
        quality="standard",
        n=1
    )
    return response.data[0].url

# Whisper (تفريغ صوت)
def transcribe_audio(audio_path: str) -> str:
    with open(audio_path, "rb") as f:
        transcription = client.audio.transcriptions.create(
            model="whisper-1",
            file=f,
            language="ar"
        )
    return transcription.text

Node.js

import OpenAI from "openai";
import dotenv from "dotenv";

dotenv.config();
const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// محادثة أساسية
async function askGPT(question, model = "gpt-5.6-luna") {
  const response = await client.chat.completions.create({
    model,
    messages: [
      { role: "system", content: "أنت مساعد ذكي." },
      { role: "user", content: question }
    ]
  });
  return response.choices[0].message.content;
}

// Streaming
async function streamGPT(question) {
  const stream = await client.chat.completions.create({
    model: "gpt-5.6",
    messages: [{ role: "user", content: question }],
    stream: true
  });
  
  for await (const chunk of stream) {
    process.stdout.write(chunk.choices[0].delta.content || "");
  }
}

Anthropic (Claude) API

Python

from anthropic import Anthropic
import os

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

# محادثة أساسية
def ask_claude(question: str, model: str = "claude-sonnet-5") -> str:
    response = client.messages.create(
        model=model,
        max_tokens=1024,
        system="أنت مساعد ذكي.",
        messages=[
            {"role": "user", "content": question}
        ]
    )
    return response.content[0].text

# Streaming
def stream_claude(question: str):
    with client.messages.stream(
        model="claude-sonnet-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": question}]
    ) as stream:
        for text in stream.text_stream:
            print(text, end="", flush=True)

# Extended Thinking (adaptive — النمط الحديث لعائلة Claude 5،
# budget_tokens الثابت أُلغي على Opus 5 ويُرفض بخطأ 400)
def ask_claude_thinking(question: str) -> tuple[str, str]:
    """Returns (thinking, answer)."""
    response = client.messages.create(
        model="claude-opus-5",
        max_tokens=2048,
        thinking={"type": "adaptive"},
        messages=[{"role": "user", "content": question}]
    )
    
    thinking = ""
    answer = ""
    for block in response.content:
        if block.type == "thinking":
            thinking = block.thinking
        elif block.type == "text":
            answer = block.text
    return thinking, answer

# محادثة متعدّدة الأدوار
def chat_history(messages: list, question: str) -> tuple[str, list]:
    messages.append({"role": "user", "content": question})
    response = client.messages.create(
        model="claude-sonnet-5",
        max_tokens=1024,
        messages=messages
    )
    reply = response.content[0].text
    messages.append({"role": "assistant", "content": reply})
    return reply, messages

# تحليل صورة
def analyze_image(image_path: str, question: str) -> str:
    import base64
    with open(image_path, "rb") as f:
        image_data = base64.standard_b64encode(f.read()).decode("utf-8")
    
    response = client.messages.create(
        model="claude-sonnet-5",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": [
                {"type": "image", "source": {
                    "type": "base64",
                    "media_type": "image/jpeg",
                    "data": image_data
                }},
                {"type": "text", "text": question}
            ]
        }]
    )
    return response.content[0].text

Node.js

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

const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

async function askClaude(question) {
  const response = await client.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: question }]
  });
  return response.content[0].text;
}

Google Gemini API

⚠️ حزمة google-generativeai القديمة (genai.GenerativeModel) صارت legacy منذ نوفمبر 2025 — الحزمة الموحّدة الحالية هي google-genai (pip install google-genai)، وتعتمد على كائن Client مركزي بدل بناء نموذج مباشرة.

Python

from google import genai
from google.genai import types
import os

client = genai.Client(api_key=os.getenv("GOOGLE_API_KEY"))
MODEL = "gemini-3.1-pro-preview"

# محادثة أساسية
def ask_gemini(question: str) -> str:
    response = client.models.generate_content(model=MODEL, contents=question)
    return response.text

# مع system instruction
def ask_gemini_with_system(question: str) -> str:
    response = client.models.generate_content(
        model=MODEL,
        contents=question,
        config=types.GenerateContentConfig(
            system_instruction="أنت مساعد ذكي بالعربية."
        ),
    )
    return response.text

# Streaming
def stream_gemini(question: str):
    for chunk in client.models.generate_content_stream(model=MODEL, contents=question):
        print(chunk.text, end="", flush=True)

# محادثة متعدّدة
def chat_gemini():
    chat = client.chats.create(model=MODEL)
    while True:
        user_input = input("أنت: ")
        if user_input.lower() == "خروج":
            break
        response = chat.send_message(message=user_input)
        print("Gemini:", response.text)

# تحليل صورة
def analyze_image_gemini(image_path: str, question: str) -> str:
    from PIL import Image
    img = Image.open(image_path)
    response = client.models.generate_content(model=MODEL, contents=[question, img])
    return response.text

# سياق ضخم (فيديو أو كتاب)
def analyze_video(video_path: str, question: str) -> str:
    video_file = client.files.upload(file=video_path)
    response = client.models.generate_content(model=MODEL, contents=[video_file, question])
    return response.text

Node.js

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY });

async function askGemini(question) {
  const response = await ai.models.generateContent({
    model: "gemini-3.1-pro-preview",
    contents: question,
  });
  return response.text;
}

مقارنة الأسعار (تحقّق حيّ 2026-09)

الأسعار تتغيّر بسرعة (خصوصاً العروض الترويجية المؤقّتة) — تحقّق دائماً من صفحة التسعير الرسمية لكل مزوّد قبل التخطيط لميزانية.

استراتيجية اقتصادية:

• Prototype: النموذج الأرخص (GPT-5.6 Luna أو Gemini Flash)
• Production: النموذج الأدقّ لمهمّتك
• Complex tasks: Opus أو نموذج استدلال متقدّم

أفضل الممارسات

1).env للـSecrets

#.env (لا تضعه في Git)
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GOOGLE_API_KEY=...

#.gitignore
.env
*.env

2) Rate Limiting

import time
from openai import RateLimitError

def safe_call(prompt, retries=3):
    for i in range(retries):
        try:
            return ask_gpt(prompt)
        except RateLimitError:
            time.sleep(2 ** i)
    raise Exception("Rate limit exceeded")

3) Caching

from functools import lru_cache

@lru_cache(maxsize=1000)
def cached_ask(question: str) -> str:
    return ask_gpt(question)

4) مراقبة التكاليف

import logging

logging.info(f"Tokens used: {response.usage.total_tokens}")
logging.info(f"Cost estimate: ${response.usage.total_tokens * 0.000002}")

5) Async للطلبات المتوازية

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))

async def batch_process(questions: list):
    tasks = [
        async_client.chat.completions.create(
            model="gpt-5.6-luna",
            messages=[{"role": "user", "content": q}]
        )
        for q in questions
    ]
    return await asyncio.gather(*tasks)

أخطاء شائعة

1) نشر API Key على GitHub

كارثة. راجع كل commit قبل الدفع.

2) عدم معالجة الأخطاء

Network fails, rate limits, invalid responses، لا تسقط تطبيقك.

3) الاستخدام بلا حدّ أعلى

اضبط max_tokens، لا تدفع لمخرج غير محدود.

4) استخدام أغلى نموذج للمهام البسيطة

Haiku/Flash/mini كافيان للمهام العادية.

5) تجاهل Caching

نفس السؤال مرّتَين = مضاعفة التكلفة. Cache للاستجابات المتكرّرة.

المصادر الرسمية

• OpenAI API Docs
• Anthropic API Docs
• Google Gemini API
• OpenAI Cookbook
• Anthropic Cookbook

---

اقرأ أيضاً: OpenAI API، دليل البدء · أفضل ١٠ أكواد Python · Claude Code، دليل المطوّر · أكواد أتمتة يومية