Google AI Studio 2026: Gemini Geliştirici Platformu

1# 1. Google AI Studio'ya git: https://aistudio.google.com
2# 2. Google hesabinla giriş yap
3# 3. Sol menuden "Get API Key" tikla
4# 4. "Create API Key in new project" seç
5 
6# API key'i environment variable olarak sakla
7export GEMINI_API_KEY="AIzaSy..."
8 
9# Test et
10curl -s "https://generativelanguage.googleapis.com/v1beta/models?key=${GEMINI_API_KEY}" | jq '.models[].name'

1// npm install @google/generative-ai
2import { GoogleGenerativeAI } from '@google/generative-ai';
3 
4const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY!);
5 
6// Model seç
7const model = genAI.getGenerativeModel({
8  model: 'gemini-2.5-pro-preview',
9  generationConfig: {
10    temperature: 0.7,
11    topP: 0.95,
12    topK: 40,
13    maxOutputTokens: 8192,
14  },
15});
16 
17// Basit bir sorgu
18async function generateResponse(prompt: string): Promise<string> {
19  const result = await model.generateContent(prompt);
20  const response = result.response;
21  return response.text();
22}
23 
24// Kullanım
25const answer = await generateResponse(
26  'Swift ve Kotlin arasindaki temel farklar nelerdir?'
27);
28console.log(answer);

1// Swift Package Manager ile ekle:
2// https://github.com/google/generative-ai-swift
3 
4import GoogleGenerativeAI
5 
6let model = GenerativeModel(
7    name: "gemini-2.5-flash",
8    apiKey: APIKey.default
9)
10 
11func generateContent() async throws -> String {
12    let response = try await model.generateContent("Merhaba Gemini!")
13    return response.text ?? "Yanit alinamadi"
14}

1// Goreve göre model secimi
2function selectModel(task: string): string {
3  switch (task) {
4    case 'code-generation':
5    case 'complex-reasoning':
6    case 'long-document-analysis':
7      return 'gemini-2.5-pro-preview';
8 
9    case 'chat':
10    case 'summarization':
11    case 'general-qa':
12      return 'gemini-2.5-flash';
13 
14    case 'classification':
15    case 'entity-extraction':
16    case 'simple-generation':
17      return 'gemini-2.5-flash-lite';
18 
19    default:
20      return 'gemini-2.5-flash'; // Varsayılan: denge modeli
21  }
22}

1const model = genAI.getGenerativeModel({
2  model: 'gemini-2.5-flash',
3  systemInstruction: {
4    parts: [{
5      text: `Sen deneyimli bir iOS geliştiricisisin.
6      Kullanıcılara Swift ve SwiftUI konularinda yardimci oluyorsun.
7 
8      Kurallar:
9      - Her zaman Turkce cevap ver
10      - Kod örnekleri Swift 6 uyumlu olsun
11      - Aciklayici ve öğretici bir ton kullan
12      - Best practice'leri vurgula
13      - Yanlış bilgi verme, emin degilsen belirt`
14    }]
15  }
16});

1const prompt = `
2Aşağıdaki örneklere bakarak verilen kodu refactor et:
3 
4Örnek 1:
5Input: let x = ["a","b","c"]; for(let i=0;i<x.length;i++){console.log(x[i])}
6Output: const items = ["a", "b", "c"];
7items.forEach(item => console.log(item));
8 
9Örnek 2:
10Input: var result = ""; for(var i=0;i<arr.length;i++){result+=arr[i]+","}
11Output: const result = arr.join(",");
12 
13Şimdi bu kodu refactor et:
14Input: let sum=0; for(let i=0;i<numbers.length;i++){sum=sum+numbers[i]}
15`;
16 
17const result = await model.generateContent(prompt);

1import { GoogleGenerativeAI, FunctionDeclarationSchemaType } from '@google/generative-ai';
2 
3const tools = [{
4  functionDeclarations: [{
5    name: 'getWeather',
6    description: 'Belirtilen sehrin hava durumu bilgisini getirir',
7    parameters: {
8      type: FunctionDeclarationSchemaType.OBJECT,
9      properties: {
10        city: {
11          type: FunctionDeclarationSchemaType.STRING,
12          description: 'Sehir adi (örnek: Istanbul)'
13        },
14        unit: {
15          type: FunctionDeclarationSchemaType.STRING,
16          enum: ['celsius', 'fahrenheit'],
17          description: 'Sicaklik birimi'
18        }
19      },
20      required: ['city']
21    }
22  }, {
23    name: 'searchProducts',
24    description: 'Ürün katalogundan arama yapar',
25    parameters: {
26      type: FunctionDeclarationSchemaType.OBJECT,
27      properties: {
28        query: {
29          type: FunctionDeclarationSchemaType.STRING,
30          description: 'Arama sorgusu'
31        },
32        maxPrice: {
33          type: FunctionDeclarationSchemaType.NUMBER,
34          description: 'Maksimum fiyat (TL)'
35        }
36      },
37      required: ['query']
38    }
39  }]
40}];
41 
42const model = genAI.getGenerativeModel({
43  model: 'gemini-2.5-flash',
44  tools
45});

1async function chatWithTools(userMessage: string): Promise<string> {
2  const chat = model.startChat();
3  let response = await chat.sendMessage(userMessage);
4 
5  // Model function call istediyse
6  while (response.response.candidates?.[0]?.content?.parts?.some(
7    part => 'functionCall' in part
8  )) {
9    const functionCalls = response.response.candidates[0].content.parts
10      .filter(part => 'functionCall' in part)
11      .map(part => part.functionCall!);
12 
13    const functionResponses = await Promise.all(
14      functionCalls.map(async (call) => {
15        const result = await executeTool(call.name, call.args);
16        return {
17          functionResponse: {
18            name: call.name,
19            response: { result }
20          }
21        };
22      })
23    );
24 
25    response = await chat.sendMessage(functionResponses);
26  }
27 
28  return response.response.text();
29}
30 
31// Tool executor
32async function executeTool(name: string, args: Record<string, unknown>) {
33  switch (name) {
34    case 'getWeather':
35      return await fetchWeatherAPI(args.city as string);
36    case 'searchProducts':
37      return await searchProductDB(args.query as string, args.maxPrice as number);
38    default:
39      throw new Error(`Bilinmeyen fonksiyon: ${name}`);
40  }
41}

1{
2  "training_data": [
3    {
4      "input": "SwiftUI'da bir liste nasil oluşturulur?",
5      "output": "SwiftUI'da liste oluşturmak için List view'i kullanılır. ForEach ile dinamik içerik render edilir ve .listStyle() modifier ile görünüm ozellestirilebilir."
6    },
7    {
8      "input": "Core Data ile SwiftData arasindaki fark nedir?",
9      "output": "SwiftData, Core Data'nin modern Swift-native alternatifidir. @Model macro'su ile tanımlama yapılır, CloudKit entegrasyonu dahilidir ve SwiftUI ile dogal olarak çalışır."
10    }
11  ]
12}

1import { HarmCategory, HarmBlockThreshold } from '@google/generative-ai';
2 
3const safetySettings = [
4  {
5    category: HarmCategory.HARM_CATEGORY_HARASSMENT,
6    threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
7  },
8  {
9    category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
10    threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
11  },
12  {
13    category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
14    threshold: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
15  },
16  {
17    category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
18    threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
19  },
20];
21 
22const model = genAI.getGenerativeModel({
23  model: 'gemini-2.5-flash',
24  safetySettings,
25});

1interface CostEstimate {
2  inputTokens: number;
3  outputTokens: number;
4  model: string;
5  totalCost: number;
6}
7 
8function estimateCost(
9  inputTokens: number,
10  outputTokens: number,
11  model: string
12): CostEstimate {
13  const pricing: Record<string, { input: number; output: number }> = {
14    'gemini-2.5-pro': { input: 1.25, output: 10.0 },    // per 1M tokens
15    'gemini-2.5-flash': { input: 0.075, output: 0.30 },
16    'gemini-2.0-flash': { input: 0.04, output: 0.16 },
17  };
18 
19  const rate = pricing[model] ?? pricing['gemini-2.5-flash'];
20  const totalCost =
21    (inputTokens / 1_000_000) * rate.input +
22    (outputTokens / 1_000_000) * rate.output;
23 
24  return { inputTokens, outputTokens, model, totalCost };
25}
26 
27// Örnek: 10K input + 2K output, Flash modeli
28const estimate = estimateCost(10_000, 2_000, 'gemini-2.5-flash');
29console.log(`Tahmini maliyet: $${estimate.totalCost.toFixed(6)}`);
30// Tahmini maliyet: $0.001350

1import GoogleGenerativeAI
2 
3actor GeminiService {
4    private let model: GenerativeModel
5 
6    init() {
7        self.model = GenerativeModel(
8            name: "gemini-2.5-flash",
9            apiKey: Configuration.geminiAPIKey,
10            generationConfig: GenerationConfig(
11                temperature: 0.7,
12                maxOutputTokens: 2048
13            )
14        )
15    }
16 
17    func chat(message: String) async throws -> String {
18        let response = try await model.generateContent(message)
19        guard let text = response.text else {
20            throw GeminiError.emptyResponse
21        }
22        return text
23    }
24 
25    func analyzeImage(_ image: UIImage, prompt: String) async throws -> String {
26        let response = try await model.generateContent(prompt, image)
27        return response.text ?? ""
28    }
29}

1// pubspec.yaml: google_generative_ai: ^0.4.0
2import 'package:google_generative_ai/google_generative_ai.dart';
3 
4class GeminiRepository {
5  late final GenerativeModel _model;
6 
7  GeminiRepository() {
8    _model = GenerativeModel(
9      model: 'gemini-2.5-flash',
10      apiKey: const String.fromEnvironment('GEMINI_API_KEY'),
11    );
12  }
13 
14  Future<String> generate(String prompt) async {
15    final content = [Content.text(prompt)];
16    final response = await _model.generateContent(content);
17    return response.text ?? '';
18  }
19}