بناء تطبيقات الذكاء الاصطناعي باستخدام Google Gemini API و TypeScript

mkdir gemini-ai-app && cd gemini-ai-app
npm init -y
npm install @google/generative-ai
npm install -D typescript @types/node tsx

npx tsc --init --target ES2022 --module NodeNext --moduleResolution NodeNext --outDir dist --rootDir src --strict

mkdir src
touch src/index.ts .env

GEMINI_API_KEY=your_api_key_here

{
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "build": "tsc",
    "start": "node dist/index.js"
  }
}

import { GoogleGenerativeAI } from "@google/generative-ai";
 
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY!);
 
async function generateText() {
  const model = genAI.getGenerativeModel({
    model: "gemini-2.5-pro",
  });
 
  const result = await model.generateContent(
    "اشرح الحوسبة الكمومية في 3 جمل لمطور برمجيات."
  );
 
  console.log(result.response.text());
}
 
generateText();

GEMINI_API_KEY=your_key tsx src/index.ts

async function inspectResponse() {
  const model = genAI.getGenerativeModel({ model: "gemini-2.5-pro" });
 
  const result = await model.generateContent("مرحباً يا Gemini!");
  const response = result.response;
 
  console.log("النص:", response.text());
  console.log("الاستخدام:", response.usageMetadata);
  // { promptTokenCount: 4, candidatesTokenCount: 12, totalTokenCount: 16 }
}

// للتحليل المعقد
const pro = genAI.getGenerativeModel({ model: "gemini-2.5-pro" });
 
// للتطبيقات التي تحتاج سرعة
const flash = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
 
// للمهام البسيطة بحجم كبير
const lite = genAI.getGenerativeModel({ model: "gemini-2.5-flash-lite" });

import { GoogleGenerativeAI } from "@google/generative-ai";
import * as fs from "fs";
import * as path from "path";
 
async function analyzeImage(imagePath: string) {
  const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
 
  const imageData = fs.readFileSync(imagePath);
  const base64Image = imageData.toString("base64");
  const mimeType = imagePath.endsWith(".png") ? "image/png" : "image/jpeg";
 
  const result = await model.generateContent([
    {
      inlineData: {
        mimeType,
        data: base64Image,
      },
    },
    "صف هذه الصورة بالتفصيل. ما الأشياء والألوان والمشهد الذي تراه؟",
  ]);
 
  console.log(result.response.text());
}
 
analyzeImage("./sample-image.jpg");

async function analyzePDF(pdfPath: string) {
  const model = genAI.getGenerativeModel({ model: "gemini-2.5-pro" });
 
  const pdfData = fs.readFileSync(pdfPath);
  const base64PDF = pdfData.toString("base64");
 
  const result = await model.generateContent([
    {
      inlineData: {
        mimeType: "application/pdf",
        data: base64PDF,
      },
    },
    "لخّص النقاط الرئيسية في هذا المستند. اذكر المواضيع الأساسية وأي بنود عمل.",
  ]);
 
  console.log(result.response.text());
}

async function compareImages(image1Path: string, image2Path: string) {
  const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
 
  const image1 = fs.readFileSync(image1Path).toString("base64");
  const image2 = fs.readFileSync(image2Path).toString("base64");
 
  const result = await model.generateContent([
    { inlineData: { mimeType: "image/jpeg", data: image1 } },
    { inlineData: { mimeType: "image/jpeg", data: image2 } },
    "قارن بين هاتين الصورتين. ما هي الاختلافات والتشابهات؟",
  ]);
 
  console.log(result.response.text());
}

async function streamResponse(prompt: string) {
  const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
 
  const result = await model.generateContentStream(prompt);
 
  process.stdout.write("Gemini: ");
 
  for await (const chunk of result.stream) {
    const text = chunk.text();
    process.stdout.write(text);
  }
 
  console.log("\n");
 
  // الوصول للاستجابة المجمعة بعد البث
  const aggregated = await result.response;
  console.log("إجمالي الرموز:", aggregated.usageMetadata?.totalTokenCount);
}
 
streamResponse("اكتب قصيدة قصيرة عن TypeScript.");

import { createServer } from "http";
 
const server = createServer(async (req, res) => {
  if (req.method === "POST" && req.url === "/chat") {
    const body = await getBody(req);
    const { message } = JSON.parse(body);
 
    const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
    const result = await model.generateContentStream(message);
 
    res.writeHead(200, {
      "Content-Type": "text/event-stream",
      "Cache-Control": "no-cache",
      Connection: "keep-alive",
    });
 
    for await (const chunk of result.stream) {
      res.write(`data: ${JSON.stringify({ text: chunk.text() })}\n\n`);
    }
 
    res.write("data: [DONE]\n\n");
    res.end();
  }
});
 
server.listen(3000, () => console.log("الخادم يعمل على المنفذ 3000"));
 
function getBody(req: any): Promise<string> {
  return new Promise((resolve) => {
    let body = "";
    req.on("data", (chunk: string) => (body += chunk));
    req.on("end", () => resolve(body));
  });
}

import {
  GoogleGenerativeAI,
  FunctionDeclarationSchemaType,
} from "@google/generative-ai";
 
const tools = [
  {
    functionDeclarations: [
      {
        name: "getWeather",
        description: "الحصول على حالة الطقس الحالية لموقع محدد",
        parameters: {
          type: FunctionDeclarationSchemaType.OBJECT,
          properties: {
            location: {
              type: FunctionDeclarationSchemaType.STRING,
              description: "اسم المدينة، مثل 'تونس' أو 'الرياض'",
            },
            unit: {
              type: FunctionDeclarationSchemaType.STRING,
              enum: ["celsius", "fahrenheit"],
              description: "وحدة الحرارة",
            },
          },
          required: ["location"],
        },
      },
      {
        name: "searchProducts",
        description: "البحث عن منتجات في الكتالوج",
        parameters: {
          type: FunctionDeclarationSchemaType.OBJECT,
          properties: {
            query: {
              type: FunctionDeclarationSchemaType.STRING,
              description: "استعلام البحث",
            },
            maxPrice: {
              type: FunctionDeclarationSchemaType.NUMBER,
              description: "فلتر السعر الأقصى",
            },
          },
          required: ["query"],
        },
      },
    ],
  },
];

// تطبيقات الدوال المحاكاة
function getWeather(location: string, unit = "celsius") {
  const mockData: Record<string, { temp: number; condition: string }> = {
    tunis: { temp: 24, condition: "مشمس" },
    riyadh: { temp: 35, condition: "صافي" },
    cairo: { temp: 28, condition: "غائم جزئياً" },
  };
 
  const data = mockData[location.toLowerCase()] || {
    temp: 20,
    condition: "غير معروف",
  };
 
  return {
    location,
    temperature: data.temp,
    unit,
    condition: data.condition,
  };
}
 
function searchProducts(query: string, maxPrice?: number) {
  return {
    results: [
      { name: `${query} Pro`, price: 99.99, rating: 4.5 },
      { name: `${query} Lite`, price: 49.99, rating: 4.2 },
    ].filter((p) => !maxPrice || p.price <= maxPrice),
  };
}
 
async function chatWithTools(userMessage: string) {
  const model = genAI.getGenerativeModel({
    model: "gemini-2.5-flash",
    tools,
  });
 
  const chat = model.startChat();
  const result = await chat.sendMessage(userMessage);
 
  const response = result.response;
  const functionCalls = response.functionCalls();
 
  if (functionCalls && functionCalls.length > 0) {
    const functionResponses = functionCalls.map((call) => {
      let result;
      switch (call.name) {
        case "getWeather":
          result = getWeather(
            call.args.location as string,
            call.args.unit as string
          );
          break;
        case "searchProducts":
          result = searchProducts(
            call.args.query as string,
            call.args.maxPrice as number
          );
          break;
        default:
          result = { error: "دالة غير معروفة" };
      }
 
      return {
        functionResponse: {
          name: call.name,
          response: result,
        },
      };
    });
 
    // إرسال نتائج الدوال إلى Gemini
    const finalResult = await chat.sendMessage(functionResponses);
    console.log(finalResult.response.text());
  } else {
    console.log(response.text());
  }
}
 
chatWithTools("ما حالة الطقس في تونس وابحث لي عن خيارات لابتوب بأقل من 80 دولار؟");

async function extractStructuredData(text: string) {
  const model = genAI.getGenerativeModel({
    model: "gemini-2.5-flash",
    generationConfig: {
      responseMimeType: "application/json",
      responseSchema: {
        type: FunctionDeclarationSchemaType.OBJECT,
        properties: {
          sentiment: {
            type: FunctionDeclarationSchemaType.STRING,
            enum: ["positive", "negative", "neutral"],
          },
          confidence: {
            type: FunctionDeclarationSchemaType.NUMBER,
          },
          topics: {
            type: FunctionDeclarationSchemaType.ARRAY,
            items: {
              type: FunctionDeclarationSchemaType.STRING,
            },
          },
          summary: {
            type: FunctionDeclarationSchemaType.STRING,
          },
        },
        required: ["sentiment", "confidence", "topics", "summary"],
      },
    },
  });
 
  const result = await model.generateContent(
    `حلل النص التالي:\n\n${text}`
  );
 
  const data = JSON.parse(result.response.text());
  return data;
}
 
// الاستخدام
const analysis = await extractStructuredData(
  "واجهة Gemini API الجديدة رائعة! التوثيق واضح، " +
  "وحزمة TypeScript SDK مصممة بشكل جيد، والأسعار تنافسية جداً. " +
  "لكن حدود المعدل يمكن أن تكون مصدر قلق للتطبيقات ذات الحركة العالية."
);
 
console.log(analysis);
// {
//   sentiment: "positive",
//   confidence: 0.85,
//   topics: ["API", "documentation", "SDK", "pricing", "rate limits"],
//   summary: "مراجعة إيجابية لـ Gemini API مع قلق بسيط حول حدود المعدل"
// }

import {
  GoogleGenerativeAI,
  HarmCategory,
  HarmBlockThreshold,
} from "@google/generative-ai";
import * as readline from "readline";
 
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY!);
 
async function startAssistant() {
  const model = genAI.getGenerativeModel({
    model: "gemini-2.5-flash",
    systemInstruction: `أنت مساعد برمجة متخصص في TypeScript و Node.js.
    تقدم إجابات موجزة وعملية مع أمثلة برمجية عند الحاجة.
    تراعي دائماً أفضل الممارسات والاعتبارات الأمنية.
    إذا لم تكن متأكداً من شيء، قل ذلك بدلاً من التخمين.`,
    safetySettings: [
      {
        category: HarmCategory.HARM_CATEGORY_HARASSMENT,
        threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
      },
      {
        category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
        threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
      },
    ],
    generationConfig: {
      temperature: 0.7,
      topP: 0.95,
      topK: 40,
      maxOutputTokens: 2048,
    },
  });
 
  const chat = model.startChat({
    history: [],
  });
 
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });
 
  console.log("المساعد الذكي جاهز! اكتب 'خروج' للإنهاء.\n");
 
  const askQuestion = () => {
    rl.question("أنت: ", async (input) => {
      const trimmed = input.trim();
      if (trimmed === "خروج" || trimmed.toLowerCase() === "exit") {
        console.log("إلى اللقاء!");
        rl.close();
        return;
      }
 
      try {
        const result = await chat.sendMessageStream(trimmed);
 
        process.stdout.write("المساعد: ");
        for await (const chunk of result.stream) {
          process.stdout.write(chunk.text());
        }
        console.log("\n");
      } catch (error: any) {
        console.error("خطأ:", error.message);
      }
 
      askQuestion();
    });
  };
 
  askQuestion();
}
 
startAssistant();

import { GoogleGenerativeAI, GoogleGenerativeAIError } from "@google/generative-ai";
 
async function safeGenerate(prompt: string, retries = 3): Promise<string> {
  const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
 
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      const result = await model.generateContent(prompt);
      return result.response.text();
    } catch (error: any) {
      const status = error?.status;
 
      if (status === 429) {
        // تجاوز حد المعدل — تراجع أسي
        const delay = Math.pow(2, attempt) * 1000;
        console.warn(
          `تم تجاوز حد المعدل. إعادة المحاولة خلال ${delay / 1000} ثانية (المحاولة ${attempt}/${retries})`
        );
        await new Promise((r) => setTimeout(r, delay));
        continue;
      }
 
      if (status === 400) {
        console.error("طلب غير صالح — تحقق من الأمر أو المعاملات");
        throw error;
      }
 
      if (status === 403) {
        console.error("مفتاح API غير صالح أو تم تجاوز الحصة");
        throw error;
      }
 
      if (attempt === retries) throw error;
 
      console.warn(`خطأ (المحاولة ${attempt}/${retries}):`, error.message);
      await new Promise((r) => setTimeout(r, 1000 * attempt));
    }
  }
 
  throw new Error("تم تجاوز الحد الأقصى للمحاولات");
}

// src/config.ts
interface GeminiConfig {
  apiKey: string;
  model: string;
  maxRetries: number;
  timeout: number;
}
 
export function getConfig(): GeminiConfig {
  const apiKey = process.env.GEMINI_API_KEY;
  if (!apiKey) {
    throw new Error("متغير البيئة GEMINI_API_KEY مطلوب");
  }
 
  return {
    apiKey,
    model: process.env.GEMINI_MODEL || "gemini-2.5-flash",
    maxRetries: parseInt(process.env.GEMINI_MAX_RETRIES || "3", 10),
    timeout: parseInt(process.env.GEMINI_TIMEOUT || "30000", 10),
  };
}

async function countTokens(content: string) {
  const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
 
  const result = await model.countTokens(content);
  console.log(`عدد الرموز: ${result.totalTokens}`);
 
  return result.totalTokens;
}

function estimateCost(
  inputTokens: number,
  outputTokens: number,
  model: "pro" | "flash" | "flash-lite"
) {
  // أسعار تقريبية لكل مليون رمز (تحقق من الأسعار الحالية)
  const pricing = {
    pro: { input: 1.25, output: 10.0 },
    flash: { input: 0.15, output: 0.6 },
    "flash-lite": { input: 0.075, output: 0.3 },
  };
 
  const p = pricing[model];
  const inputCost = (inputTokens / 1_000_000) * p.input;
  const outputCost = (outputTokens / 1_000_000) * p.output;
 
  return {
    inputCost: `$${inputCost.toFixed(4)}`,
    outputCost: `$${outputCost.toFixed(4)}`,
    totalCost: `$${(inputCost + outputCost).toFixed(4)}`,
  };
}