Gemini API Kullanımı ve Entegrasyon

Gemini API Kullanımı ve Entegrasyon Prompt Şablonları

Bu rehber, Google Gemini API ile uygulama geliştirme süreçlerinizi hızlandırmak için tasarlanmış kapsamlı prompt şablonlarını ve kod örneklerini içermektedir. Temel API kullanımından gelişmiş multimodal uygulamalara, chat sistemlerinden production deployment stratejilerine kadar geniş bir yelpazede kullanabileceğiniz şablonlar sunulmaktadır.

🚀 Kullanım Notu: Şablonlardaki [KÖŞELİ PARANTEZ] içindeki alanları kendi projenize göre doldurun. API anahtarlarınızı güvenli tutun ve rate limitlere dikkat edin. Production ortamında hata yönetimi ve retry mekanizmaları eklemeyi unutmayın.

Başlangıç ve Kurulum

API Anahtarı Alma ve Proje Kurulumu

Gemini API ile başlamak için gerekli adımlar.

Gemini API projesi kurulumu için adım adım rehber oluştur.



PROJE TÜRÜ: [Web app / Mobile app / Backend service / CLI tool]

PROGRAMLAMA DİLİ: [Python / JavaScript / Node.js / Go / Dart]



KURULUM REHBERİ:



1. API ANAHTARI ALMA:



   Adım 1: Google AI Studio sayfasına git

   - URL: https://makersuite.google.com/app/apikey

   - Google hesabınla giriş yap



   Adım 2: API Key oluştur

   - Create API Key butonuna tıkla

   - Projen için yeni key oluştur veya mevcut GCP projesini seç

   - Key i güvenli bir yerde sakla



   Adım 3: API Key i test et

   - Google AI Studio da Prompt Gallery den bir örnek dene

   - API key in çalıştığını doğrula



2. SDK KURULUMU:



   Python için:

   pip install google-generativeai



   Node.js için:

   npm install @google/generative-ai



   Go için:

   go get github.com/google/generative-ai-go



3. ENVIRONMENT AYARLARI:



   .env dosyası oluştur:

   GOOGLE_API_KEY=your_api_key_here



   Python ile yükleme:

   import os

   from dotenv import load_dotenv

   load_dotenv()

   api_key = os.getenv("GOOGLE_API_KEY")



   Node.js ile yükleme:

   require("dotenv").config();

   const apiKey = process.env.GOOGLE_API_KEY;



4. İLK BAĞLANTI TESTİ:



   Python:

   import google.generativeai as genai

   

   genai.configure(api_key=api_key)

   model = genai.GenerativeModel("gemini-pro")

   response = model.generate_content("Merhaba, nasılsın?")

   print(response.text)



   Node.js:

   const { GoogleGenerativeAI } = require("@google/generative-ai");

   

   const genAI = new GoogleGenerativeAI(apiKey);

   const model = genAI.getGenerativeModel({ model: "gemini-pro" });

   

   async function run() {

     const result = await model.generateContent("Merhaba, nasılsın?");

     console.log(result.response.text());

   }

   run();



5. MODEL SEÇENEKLERİ:



   | Model | Kullanım Alanı | Özellikler |

   |-------|----------------|------------|

   | gemini-pro | Metin işleme | Hızlı, genel amaçlı |

   | gemini-pro-vision | Görsel + Metin | Multimodal analiz |

   | gemini-1.5-pro | Uzun bağlam | 1M token context |

   | gemini-1.5-flash | Hızlı yanıt | Düşük latency |



6. RATE LIMITS:



   Ücretsiz katman:

   - 60 istek/dakika

   - 1500 istek/gün

   

   Ücretli katman:

   - Daha yüksek limitler

   - SLA garantisi

Temel API Yapılandırması

API parametreleri ve konfigürasyon seçenekleri.

Gemini API yapılandırma şablonu oluştur.



KULLANIM SENARYOSU: [Chat / Analiz / Üretim / Özetleme]



API YAPILANDIRMASI:



1. GENERATION CONFIG:



   Python:

   generation_config = {

       "temperature": 0.7,        # 0.0-1.0 arası, yaratıcılık seviyesi

       "top_p": 0.95,             # Nucleus sampling

       "top_k": 40,               # Top-k sampling

       "max_output_tokens": 2048, # Maksimum çıktı uzunluğu

       "stop_sequences": ["END"] # Durma işaretleri

   }



   model = genai.GenerativeModel(

       model_name="gemini-pro",

       generation_config=generation_config

   )



2. SAFETY SETTINGS:



   from google.generativeai.types import HarmCategory, HarmBlockThreshold



   safety_settings = {

       HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,

       HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,

       HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,

       HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,

   }



   model = genai.GenerativeModel(

       model_name="gemini-pro",

       safety_settings=safety_settings

   )



3. SYSTEM INSTRUCTION:



   model = genai.GenerativeModel(

       model_name="gemini-1.5-pro",

       system_instruction="Sen yardımcı bir asistansın. Türkçe yanıt ver ve nazik ol."

   )



4. TEMPERATURE KILAVUZU:



   | Değer | Kullanım | Örnek |

   |-------|----------|-------|

   | 0.0-0.3 | Tutarlı, deterministik | Kod üretimi, analiz |

   | 0.4-0.6 | Dengeli | Genel sohbet |

   | 0.7-0.9 | Yaratıcı | Hikaye yazma |

   | 1.0 | Çok yaratıcı | Beyin fırtınası |



5. TOKEN LİMİTLERİ:



   gemini-pro:

   - Input: 30,720 token

   - Output: 2,048 token



   gemini-1.5-pro:

   - Input: 1,048,576 token (1M)

   - Output: 8,192 token



   gemini-1.5-flash:

   - Input: 1,048,576 token (1M)

   - Output: 8,192 token

Temel Kullanım Şablonları

Metin Üretimi (Text Generation)

Temel metin üretimi için API kullanımı.

Gemini API ile metin üretimi şablonları oluştur.



PYTHON ÖRNEKLERİ:



1. TEMEL METİN ÜRETİMİ:



import google.generativeai as genai



genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemini-pro")



# Basit prompt

response = model.generate_content("Python ile web scraping nasıl yapılır?")

print(response.text)



# Prompt with context

prompt = """

Aşağıdaki konuda detaylı bir açıklama yaz:



Konu: [KONU]

Hedef Kitle: [Başlangıç / Orta / İleri]

Uzunluk: [Kısa / Orta / Detaylı]

Dil: Türkçe



Lütfen örnekler ve pratik ipuçları ekle.

"""



response = model.generate_content(prompt)

print(response.text)



2. YAPILANDIRILMIŞ ÇIKTI:



prompt = """

Aşağıdaki ürün için JSON formatında bilgi oluştur:



Ürün: [ÜRÜN ADI]



JSON formatı:

{

  "urun_adi": "",

  "kategori": "",

  "ozellikler": [],

  "fiyat_araligi": "",

  "hedef_kitle": ""

}



Sadece JSON döndür, başka açıklama ekleme.

"""



response = model.generate_content(prompt)

# JSON parse

import json

data = json.loads(response.text)



3. ÇOK ADIMLI GÖREVLER:



def multi_step_task(topic):

    model = genai.GenerativeModel("gemini-pro")

    

    # Adım 1: Araştırma

    step1 = model.generate_content(f"'{topic}' hakkında ana noktaları listele.")

    

    # Adım 2: Detaylandırma

    step2 = model.generate_content(

        f"Bu noktaları detaylandır: {step1.text}"

    )

    

    # Adım 3: Özet

    step3 = model.generate_content(

        f"Aşağıdaki içeriği 3 paragrafta özetle: {step2.text}"

    )

    

    return step3.text



4. BATCH İŞLEME:



async def batch_generate(prompts):

    model = genai.GenerativeModel("gemini-pro")

    results = []

    

    for prompt in prompts:

        try:

            response = model.generate_content(prompt)

            results.append({

                "prompt": prompt,

                "response": response.text,

                "status": "success"

            })

        except Exception as e:

            results.append({

                "prompt": prompt,

                "error": str(e),

                "status": "error"

            })

    

    return results



# Kullanım

prompts = [

    "Python nedir?",

    "JavaScript nedir?",

    "Go nedir?"

]

results = await batch_generate(prompts)

Chat ve Konuşma Yönetimi

Çok turlu konuşmalar ve chat uygulamaları için.

Gemini API ile chat uygulaması şablonu oluştur.



CHAT UYGULAMASI:



1. TEMEL CHAT OTURUMU:



import google.generativeai as genai



genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemini-pro")



# Chat oturumu başlat

chat = model.start_chat(history=[])



# Mesaj gönder

response = chat.send_message("Merhaba! Bugün hava nasıl?")

print(response.text)



# Devam et

response = chat.send_message("Yağmurlu havalarda ne yapmalıyım?")

print(response.text)



# Geçmişi görüntüle

for message in chat.history:

    print(f"{message.role}: {message.parts[0].text}")



2. ÖNCEKİ GEÇMİŞ İLE BAŞLATMA:



history = [

    {

        "role": "user",

        "parts": ["Sen bir Python uzmanısın."]

    },

    {

        "role": "model",

        "parts": ["Evet, Python konusunda size yardımcı olabilirim. Nasıl yardımcı olabilirim?"]

    }

]



chat = model.start_chat(history=history)

response = chat.send_message("List comprehension nedir?")



3. CHAT SINIFI OLUŞTURMA:



class GeminiChat:

    def __init__(self, system_prompt=None):

        genai.configure(api_key="YOUR_API_KEY")

        

        if system_prompt:

            self.model = genai.GenerativeModel(

                "gemini-1.5-pro",

                system_instruction=system_prompt

            )

        else:

            self.model = genai.GenerativeModel("gemini-pro")

        

        self.chat = self.model.start_chat(history=[])

        self.conversation_history = []

    

    def send_message(self, message):

        try:

            response = self.chat.send_message(message)

            

            self.conversation_history.append({

                "role": "user",

                "content": message

            })

            self.conversation_history.append({

                "role": "assistant",

                "content": response.text

            })

            

            return response.text

        except Exception as e:

            return f"Hata: {str(e)}"

    

    def get_history(self):

        return self.conversation_history

    

    def clear_history(self):

        self.chat = self.model.start_chat(history=[])

        self.conversation_history = []

    

    def save_history(self, filename):

        import json

        with open(filename, "w", encoding="utf-8") as f:

            json.dump(self.conversation_history, f, ensure_ascii=False, indent=2)

    

    def load_history(self, filename):

        import json

        with open(filename, "r", encoding="utf-8") as f:

            self.conversation_history = json.load(f)



# Kullanım

chat_bot = GeminiChat(system_prompt="Sen yardımcı bir Türkçe asistansın.")

print(chat_bot.send_message("Merhaba!"))

print(chat_bot.send_message("Bana Python öğret."))



4. STREAMING CHAT:



def stream_chat(message):

    model = genai.GenerativeModel("gemini-pro")

    chat = model.start_chat(history=[])

    

    response = chat.send_message(message, stream=True)

    

    full_response = ""

    for chunk in response:

        print(chunk.text, end="", flush=True)

        full_response += chunk.text

    

    print()  # Yeni satır

    return full_response



5. CONTEXT WINDOW YÖNETİMİ:



class ContextManagedChat:

    def __init__(self, max_history=10):

        self.model = genai.GenerativeModel("gemini-pro")

        self.max_history = max_history

        self.history = []

    

    def send_message(self, message):

        # Geçmişi sınırla

        if len(self.history) > self.max_history * 2:

            self.history = self.history[-self.max_history * 2:]

        

        chat = self.model.start_chat(history=self.history)

        response = chat.send_message(message)

        

        # Geçmişi güncelle

        self.history = list(chat.history)

        

        return response.text

Streaming Yanıtlar

Gerçek zamanlı streaming çıktı için.

Gemini API streaming kullanımı şablonu oluştur.



STREAMING ÖRNEKLERİ:



1. TEMEL STREAMING (Python):



import google.generativeai as genai



genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemini-pro")



# Streaming ile generate

response = model.generate_content(

    "Yapay zeka hakkında detaylı bir makale yaz.",

    stream=True

)



for chunk in response:

    print(chunk.text, end="", flush=True)



2. STREAMING İLE PROGRESS:



def generate_with_progress(prompt):

    model = genai.GenerativeModel("gemini-pro")

    

    response = model.generate_content(prompt, stream=True)

    

    full_text = ""

    chunk_count = 0

    

    for chunk in response:

        chunk_count += 1

        full_text += chunk.text

        

        # Progress göster

        print(f"Chunk {chunk_count} alındı ({len(full_text)} karakter)")

    

    return full_text



3. NODE.JS STREAMING:



const { GoogleGenerativeAI } = require("@google/generative-ai");



const genAI = new GoogleGenerativeAI(process.env.API_KEY);



async function streamResponse() {

  const model = genAI.getGenerativeModel({ model: "gemini-pro" });



  const result = await model.generateContentStream(

    "Türkiye tarihi hakkında bilgi ver."

  );



  for await (const chunk of result.stream) {

    const text = chunk.text();

    process.stdout.write(text);

  }

}



4. WEB UYGULAMASINDA STREAMING:



# Flask ile Server-Sent Events



from flask import Flask, Response, stream_with_context

import google.generativeai as genai



app = Flask(__name__)

genai.configure(api_key="YOUR_API_KEY")



@app.route("/stream")

def stream():

    def generate():

        model = genai.GenerativeModel("gemini-pro")

        response = model.generate_content(

            "Uzun bir hikaye anlat.",

            stream=True

        )

        

        for chunk in response:

            yield f"data: {chunk.text}\n\n"

        

        yield "data: [DONE]\n\n"

    

    return Response(

        stream_with_context(generate()),

        mimetype="text/event-stream"

    )



# Frontend JavaScript

const eventSource = new EventSource("/stream");



eventSource.onmessage = (event) => {

  if (event.data === "[DONE]") {

    eventSource.close();

    return;

  }

  document.getElementById("output").innerText += event.data;

};



5. ASYNC STREAMING:



import asyncio

import google.generativeai as genai



async def async_stream(prompt):

    model = genai.GenerativeModel("gemini-pro")

    

    response = await model.generate_content_async(

        prompt,

        stream=True

    )

    

    async for chunk in response:

        yield chunk.text



# Kullanım

async def main():

    async for text in async_stream("Merhaba, nasılsın?"):

        print(text, end="", flush=True)



asyncio.run(main())

Multimodal Kullanım (Görsel + Metin)

Görsel Analizi

Gemini Pro Vision ile görsel analiz.

Gemini Vision API kullanımı şablonları oluştur.



GÖRSEL ANALİZ ÖRNEKLERİ:



1. TEMEL GÖRSEL ANALİZİ:



import google.generativeai as genai

from PIL import Image



genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemini-pro-vision")



# Yerel dosyadan

image = Image.open("image.jpg")

response = model.generate_content(["Bu görseli açıkla.", image])

print(response.text)



# URL den (önce indirmek gerekir)

import requests

from io import BytesIO



url = "https://example.com/image.jpg"

response = requests.get(url)

image = Image.open(BytesIO(response.content))



response = model.generate_content(["Bu görselde ne var?", image])

print(response.text)



2. DETAYLI GÖRSEL ANALİZİ:



def analyze_image(image_path, analysis_type="general"):

    model = genai.GenerativeModel("gemini-pro-vision")

    image = Image.open(image_path)

    

    prompts = {

        "general": "Bu görseli detaylı olarak açıkla.",

        "objects": "Bu görseldeki tüm nesneleri listele.",

        "text": "Bu görseldeki tüm metinleri oku ve transkript et.",

        "colors": "Bu görseldeki ana renkleri ve renk paletini analiz et.",

        "mood": "Bu görselin duygusal tonunu ve atmosferini açıkla.",

        "technical": "Bu görselin teknik özelliklerini analiz et (kompozisyon, ışık, vb.)"

    }

    

    prompt = prompts.get(analysis_type, prompts["general"])

    response = model.generate_content([prompt, image])

    

    return response.text



# Kullanım

result = analyze_image("photo.jpg", "objects")

print(result)



3. ÇOKLU GÖRSEL KARŞILAŞTIRMA:



def compare_images(image_paths, comparison_prompt):

    model = genai.GenerativeModel("gemini-pro-vision")

    

    images = [Image.open(path) for path in image_paths]

    

    content = [comparison_prompt] + images

    response = model.generate_content(content)

    

    return response.text



# Kullanım

images = ["image1.jpg", "image2.jpg"]

result = compare_images(

    images,

    "Bu iki görseli karşılaştır. Benzerlikler ve farklılıklar neler?"

)



4. OCR - METİN OKUMA:



def extract_text_from_image(image_path):

    model = genai.GenerativeModel("gemini-pro-vision")

    image = Image.open(image_path)

    

    prompt = """

    Bu görseldeki tüm metinleri oku ve transkript et.

    

    Format:

    - Metni olduğu gibi yaz

    - Paragrafları koru

    - Varsa başlıkları belirt

    

    Sadece okunan metni döndür.

    """

    

    response = model.generate_content([prompt, image])

    return response.text



5. GÖRSEL SORU-CEVAP:



def visual_qa(image_path, question):

    model = genai.GenerativeModel("gemini-pro-vision")

    image = Image.open(image_path)

    

    response = model.generate_content([question, image])

    return response.text



# Kullanım

answer = visual_qa("chart.png", "Bu grafikte en yüksek değer nedir?")



6. BASE64 GÖRSEL:



import base64



def analyze_base64_image(base64_string, prompt):

    model = genai.GenerativeModel("gemini-pro-vision")

    

    # Base64 to image

    image_data = base64.b64decode(base64_string)

    image = Image.open(BytesIO(image_data))

    

    response = model.generate_content([prompt, image])

    return response.text



7. VIDEO FRAME ANALİZİ:



import cv2



def analyze_video_frames(video_path, frame_interval=30):

    model = genai.GenerativeModel("gemini-pro-vision")

    

    cap = cv2.VideoCapture(video_path)

    frame_count = 0

    analyses = []

    

    while cap.isOpened():

        ret, frame = cap.read()

        if not ret:

            break

        

        if frame_count % frame_interval == 0:

            # OpenCV BGR to RGB

            rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

            image = Image.fromarray(rgb_frame)

            

            response = model.generate_content([

                f"Frame {frame_count}: Bu karede ne oluyor?",

                image

            ])

            

            analyses.append({

                "frame": frame_count,

                "analysis": response.text

            })

        

        frame_count += 1

    

    cap.release()

    return analyses

Doküman Analizi

PDF ve doküman analizi için.

Gemini ile doküman analizi şablonları oluştur.



DOKÜMAN ANALİZİ:



1. PDF ANALİZİ (Sayfa Görseli):



from pdf2image import convert_from_path

import google.generativeai as genai



def analyze_pdf(pdf_path, pages=None):

    model = genai.GenerativeModel("gemini-pro-vision")

    

    # PDF sayfalarını görsele çevir

    images = convert_from_path(pdf_path)

    

    if pages:

        images = [images for i in pages if i < len(images)]

    

    results = []

    for i, image in enumerate(images):

        response = model.generate_content([

            f"Sayfa {i+1}: Bu sayfadaki içeriği özetle.",

            image

        ])

        results.append({

            "page": i + 1,

            "summary": response.text

        })

    

    return results



2. FATURA/BELGE OKUMA:



def extract_invoice_data(image_path):

    model = genai.GenerativeModel("gemini-pro-vision")

    image = Image.open(image_path)

    

    prompt = """

    Bu faturadan aşağıdaki bilgileri çıkar ve JSON formatında döndür:

    

    {

        "fatura_no": "",

        "tarih": "",

        "satici": {

            "ad": "",

            "adres": "",

            "vergi_no": ""

        },

        "alici": {

            "ad": "",

            "adres": ""

        },

        "kalemler": [

            {

                "aciklama": "",

                "miktar": 0,

                "birim_fiyat": 0,

                "toplam": 0

            }

        ],

        "ara_toplam": 0,

        "kdv": 0,

        "genel_toplam": 0

    }

    

    Sadece JSON döndür.

    """

    

    response = model.generate_content([prompt, image])

    

    import json

    return json.loads(response.text)



3. TABLO VERİSİ ÇIKARMA:



def extract_table_from_image(image_path):

    model = genai.GenerativeModel("gemini-pro-vision")

    image = Image.open(image_path)

    

    prompt = """

    Bu görseldeki tabloyu CSV formatında çıkar.

    

    Kurallar:

    - Her satır yeni bir satırda olsun

    - Sütunları virgül ile ayır

    - Başlık satırını dahil et

    

    Sadece CSV verisini döndür.

    """

    

    response = model.generate_content([prompt, image])

    return response.text



4. KARTVİZİT OKUMA:



def read_business_card(image_path):

    model = genai.GenerativeModel("gemini-pro-vision")

    image = Image.open(image_path)

    

    prompt = """

    Bu kartvizitteki bilgileri JSON olarak çıkar:

    

    {

        "ad_soyad": "",

        "unvan": "",

        "sirket": "",

        "telefon": [],

        "email": [],

        "adres": "",

        "website": "",

        "sosyal_medya": {}

    }

    """

    

    response = model.generate_content([prompt, image])

    

    import json

    return json.loads(response.text)

Gelişmiş Kullanım Şablonları

Function Calling

Gemini Function Calling kullanımı şablonu oluştur.



FUNCTION CALLING:



1. FONKSİYON TANIMLAMA:



import google.generativeai as genai



# Fonksiyon tanımları

get_weather_func = genai.protos.FunctionDeclaration(

    name="get_weather",

    description="Belirtilen şehir için hava durumu bilgisini getirir.",

    parameters=genai.protos.Schema(

        type=genai.protos.Type.OBJECT,

        properties={

            "city": genai.protos.Schema(

                type=genai.protos.Type.STRING,

                description="Şehir adı"

            ),

            "unit": genai.protos.Schema(

                type=genai.protos.Type.STRING,

                enum=["celsius", "fahrenheit"],

                description="Sıcaklık birimi"

            )

        },

        required=["city"]

    )

)



search_products_func = genai.protos.FunctionDeclaration(

    name="search_products",

    description="Ürün araması yapar.",

    parameters=genai.protos.Schema(

        type=genai.protos.Type.OBJECT,

        properties={

            "query": genai.protos.Schema(

                type=genai.protos.Type.STRING,

                description="Arama sorgusu"

            ),

            "category": genai.protos.Schema(

                type=genai.protos.Type.STRING,

                description="Ürün kategorisi"

            ),

            "max_price": genai.protos.Schema(

                type=genai.protos.Type.NUMBER,

                description="Maksimum fiyat"

            )

        },

        required=["query"]

    )

)



2. TOOL OLUŞTURMA:



tools = genai.protos.Tool(

    function_declarations=[get_weather_func, search_products_func]

)



model = genai.GenerativeModel(

    "gemini-pro",

    tools=[tools]

)



3. FONKSİYON ÇAĞRISI İŞLEME:



def handle_function_call(response):

    # Fonksiyon çağrısı var mı kontrol et

    if response.candidates[0].content.parts[0].function_call:

        fc = response.candidates[0].content.parts[0].function_call

        

        function_name = fc.name

        function_args = dict(fc.args)

        

        return {

            "function": function_name,

            "arguments": function_args

        }

    

    return None



4. TAM ÖRNEK AKIŞ:



# Gerçek fonksiyonlar

def get_weather(city, unit="celsius"):

    # API çağrısı simülasyonu

    return {

        "city": city,

        "temperature": 22,

        "unit": unit,

        "condition": "Güneşli"

    }



def search_products(query, category=None, max_price=None):

    # Veritabanı sorgusu simülasyonu

    return [

        {"name": f"{query} Ürün 1", "price": 100},

        {"name": f"{query} Ürün 2", "price": 150}

    ]



# Fonksiyon haritası

function_map = {

    "get_weather": get_weather,

    "search_products": search_products

}



def process_with_functions(user_message):

    chat = model.start_chat()

    response = chat.send_message(user_message)

    

    # Fonksiyon çağrısı kontrol

    fc_result = handle_function_call(response)

    

    if fc_result:

        # Fonksiyonu çalıştır

        func = function_map[fc_result["function"]]

        result = func(fc_result["arguments"])

        

        # Sonucu modele gönder

        response = chat.send_message(

            genai.protos.Content(

                parts=[genai.protos.Part(

                    function_response=genai.protos.FunctionResponse(

                        name=fc_result["function"],

                        response={"result": result}

                    )

                )]

            )

        )

    

    return response.text



# Kullanım

result = process_with_functions("İstanbul hava durumu nasıl?")

print(result)

Gemini Embedding API kullanımı şablonu oluştur.



EMBEDDING İŞLEMLERİ:



1. TEMEL EMBEDDING:



import google.generativeai as genai



genai.configure(api_key="YOUR_API_KEY")



def get_embedding(text, task_type="retrieval_document"):

    result = genai.embed_content(

        model="models/embedding-001",

        content=text,

        task_type=task_type

    )

    return result["embedding"]



# Kullanım

embedding = get_embedding("Python programlama dili")

print(f"Embedding boyutu: {len(embedding)}")



2. TASK TYPES:



# retrieval_query: Arama sorgusu için

# retrieval_document: Döküman indexleme için

# semantic_similarity: Benzerlik karşılaştırma için

# classification: Sınıflandırma için

# clustering: Kümeleme için



query_embedding = get_embedding(

    "Python nedir?",

    task_type="retrieval_query"

)



doc_embedding = get_embedding(

    "Python yüksek seviyeli bir programlama dilidir.",

    task_type="retrieval_document"

)



3. BATCH EMBEDDING:



def get_batch_embeddings(texts, task_type="retrieval_document"):

    embeddings = []

    

    for text in texts:

        result = genai.embed_content(

            model="models/embedding-001",

            content=text,

            task_type=task_type

        )

        embeddings.append(result["embedding"])

    

    return embeddings



4. SEMANTIC SEARCH:



import numpy as np



def cosine_similarity(a, b):

    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))



class SemanticSearch:

    def __init__(self):

        self.documents = []

        self.embeddings = []

    

    def add_documents(self, documents):

        for doc in documents:

            embedding = get_embedding(doc, "retrieval_document")

            self.documents.append(doc)

            self.embeddings.append(embedding)

    

    def search(self, query, top_k=5):

        query_embedding = get_embedding(query, "retrieval_query")

        

        similarities = []

        for i, doc_embedding in enumerate(self.embeddings):

            sim = cosine_similarity(query_embedding, doc_embedding)

            similarities.append((i, sim))

        

        # Sırala ve en iyi k sonucu döndür

        similarities.sort(key=lambda x: x[1], reverse=True)

        

        results = []

        for idx, score in similarities[:top_k]:

            results.append({

                "document": self.documents[idx],

                "score": score

            })

        

        return results



# Kullanım

search_engine = SemanticSearch()



documents = [

    "Python web geliştirme için kullanılır.",

    "JavaScript tarayıcıda çalışır.",

    "Machine learning veri biliminde önemlidir.",

    "Django Python web framework üdür.",

    "React JavaScript kütüphanesidir."

]



search_engine.add_documents(documents)



results = search_engine.search("Web sitesi nasıl yapılır?")

for r in results:

    print(f"Skor: {r["score"]:.3f} - {r["document"]}")

Gemini ile RAG sistemi şablonu oluştur.



RAG SİSTEMİ:



1. TEMEL RAG SINIFI:



import google.generativeai as genai

import numpy as np



class GeminiRAG:

    def __init__(self, api_key):

        genai.configure(api_key=api_key)

        self.model = genai.GenerativeModel("gemini-pro")

        self.documents = []

        self.embeddings = []

        self.metadata = []

    

    def add_document(self, text, metadata=None):

        embedding = genai.embed_content(

            model="models/embedding-001",

            content=text,

            task_type="retrieval_document"

        )["embedding"]

        

        self.documents.append(text)

        self.embeddings.append(embedding)

        self.metadata.append(metadata or {})

    

    def retrieve(self, query, top_k=3):

        query_embedding = genai.embed_content(

            model="models/embedding-001",

            content=query,

            task_type="retrieval_query"

        )["embedding"]

        

        similarities = []

        for i, doc_emb in enumerate(self.embeddings):

            sim = np.dot(query_embedding, doc_emb) / (

                np.linalg.norm(query_embedding) * np.linalg.norm(doc_emb)

            )

            similarities.append((i, sim))

        

        similarities.sort(key=lambda x: x[1], reverse=True)

        

        results = []

        for idx, score in similarities[:top_k]:

            results.append({

                "document": self.documents[idx],

                "metadata": self.metadata[idx],

                "score": score

            })

        

        return results

    

    def generate(self, query, top_k=3):

        # İlgili dökümanları getir

        relevant_docs = self.retrieve(query, top_k)

        

        # Context oluştur

        context = "\n\n".join([

            f"Kaynak {i+1}:\n{doc["document"]}"

            for i, doc in enumerate(relevant_docs)

        ])

        

        # Prompt oluştur

        prompt = f"""Aşağıdaki bilgi kaynaklarını kullanarak soruyu yanıtla.



KAYNAKLAR:

{context}



SORU: {query}



YANITLAMA KURALLARI:

- Sadece verilen kaynaklardaki bilgileri kullan

- Kaynaklarda olmayan bilgi için "Bu bilgi kaynaklarda yok" de

- Yanıtın sonunda kullandığın kaynak numaralarını belirt



YANIT:"""

        

        response = self.model.generate_content(prompt)

        

        return {

            "answer": response.text,

            "sources": relevant_docs

        }



# Kullanım

rag = GeminiRAG("YOUR_API_KEY")



# Dökümanları ekle

rag.add_document(

    "Python 1991 yılında Guido van Rossum tarafından geliştirildi.",

    {"source": "wikipedia", "topic": "python"}

)

rag.add_document(

    "Python web geliştirme, veri bilimi ve yapay zeka alanlarında kullanılır.",

    {"source": "docs", "topic": "python"}

)

rag.add_document(

    "Django ve Flask Python un popüler web framework leridir.",

    {"source": "blog", "topic": "python-web"}

)



# Soru sor

result = rag.generate("Python ne zaman ve kim tarafından geliştirildi?")

print(result["answer"])



2. CHUNKING STRATEJİSİ:



def chunk_text(text, chunk_size=500, overlap=50):

    words = text.split()

    chunks = []

    

    for i in range(0, len(words), chunk_size - overlap):

        chunk = " ".join(words[i:i + chunk_size])

        chunks.append(chunk)

    

    return chunks



def add_long_document(rag, text, metadata=None):

    chunks = chunk_text(text)

    

    for i, chunk in enumerate(chunks):

        chunk_metadata = (metadata or {}).copy()

        chunk_metadata["chunk_index"] = i

        rag.add_document(chunk, chunk_metadata)

Gemini API ile chatbot uygulaması şablonu oluştur.



CHATBOT UYGULAMASI:



1. FLASK BACKEND:



from flask import Flask, request, jsonify, Response

from flask_cors import CORS

import google.generativeai as genai

import json



app = Flask(__name__)

CORS(app)



genai.configure(api_key="YOUR_API_KEY")



# Oturum yönetimi

sessions = {}



def get_or_create_session(session_id):

    if session_id not in sessions:

        model = genai.GenerativeModel(

            "gemini-pro",

            system_instruction="Sen yardımcı bir Türkçe asistansın. Nazik ve bilgilendirici ol."

        )

        sessions[session_id] = model.start_chat(history=[])

    return sessions[session_id]



@app.route("/chat", methods=["POST"])

def chat():

    data = request.json

    session_id = data.get("session_id", "default")

    message = data.get("message", "")

    

    if not message:

        return jsonify({"error": "Mesaj gerekli"}), 400

    

    try:

        chat = get_or_create_session(session_id)

        response = chat.send_message(message)

        

        return jsonify({

            "response": response.text,

            "session_id": session_id

        })

    except Exception as e:

        return jsonify({"error": str(e)}), 500



@app.route("/chat/stream", methods=["POST"])

def chat_stream():

    data = request.json

    session_id = data.get("session_id", "default")

    message = data.get("message", "")

    

    def generate():

        chat = get_or_create_session(session_id)

        response = chat.send_message(message, stream=True)

        

        for chunk in response:

            yield f"data: {json.dumps({"text": chunk.text})}\n\n"

        

        yield f"data: {json.dumps({"done": True})}\n\n"

    

    return Response(generate(), mimetype="text/event-stream")



@app.route("/chat/history", methods=["GET"])

def get_history():

    session_id = request.args.get("session_id", "default")

    

    if session_id not in sessions:

        return jsonify({"history": []})

    

    chat = sessions[session_id]

    history = []

    

    for message in chat.history:

        history.append({

            "role": message.role,

            "content": message.parts[0].text

        })

    

    return jsonify({"history": history})



@app.route("/chat/clear", methods=["POST"])

def clear_history():

    data = request.json

    session_id = data.get("session_id", "default")

    

    if session_id in sessions:

        del sessions[session_id]

    

    return jsonify({"status": "cleared"})



if __name__ == "__main__":

    app.run(debug=True)



2. FRONTEND (HTML/JS):



<!DOCTYPE html>

<html>

<head>

    <title>Gemini Chatbot</title>

    <style>

        .chat-container { max-width: 600px; margin: 0 auto; padding: 20px; }

        .messages { height: 400px; overflow-y: auto; border: 1px solid #ccc; padding: 10px; }

        .message { margin: 10px 0; padding: 10px; border-radius: 8px; }

        .user { background: #e3f2fd; text-align: right; }

        .assistant { background: #f5f5f5; }

        .input-area { display: flex; margin-top: 10px; }

        .input-area input { flex: 1; padding: 10px; }

        .input-area button { padding: 10px 20px; }

    </style>

</head>

<body>

    <div class="chat-container">

        <div class="messages" id="messages"></div>

        <div class="input-area">

            <input type="text" id="input" placeholder="Mesajınızı yazın...">

            <button onclick="sendMessage()">Gönder</button>

        </div>

    </div>

    

    <script>

        const sessionId = "session_" + Date.now();

        

        async function sendMessage() {

            const input = document.getElementById("input");

            const message = input.value.trim();

            if (!message) return;

            

            addMessage(message, "user");

            input.value = "";

            

            // Streaming response

            const eventSource = new EventSource(

                "/chat/stream?session_id=" + sessionId + "&message=" + encodeURIComponent(message)

            );

            

            let assistantMessage = "";

            const msgEl = addMessage("", "assistant");

            

            eventSource.onmessage = (event) => {

                const data = JSON.parse(event.data);

                if (data.done) {

                    eventSource.close();

                    return;

                }

                assistantMessage += data.text;

                msgEl.textContent = assistantMessage;

            };

        }

        

        function addMessage(text, role) {

            const messages = document.getElementById("messages");

            const div = document.createElement("div");

            div.className = "message " + role;

            div.textContent = text;

            messages.appendChild(div);

            messages.scrollTop = messages.scrollHeight;

            return div;

        }

        

        document.getElementById("input").addEventListener("keypress", (e) => {

            if (e.key === "Enter") sendMessage();

        });

    </script>

</body>

</html>

Gemini ile içerik üretici uygulaması şablonu oluştur.



İÇERİK ÜRETİCİ:



import google.generativeai as genai



class ContentGenerator:

    def __init__(self, api_key):

        genai.configure(api_key=api_key)

        self.model = genai.GenerativeModel("gemini-pro")

    

    def generate_blog_post(self, topic, tone="professional", length="medium"):

        length_guide = {

            "short": "500 kelime",

            "medium": "1000 kelime",

            "long": "2000 kelime"

        }

        

        prompt = f"""

        Aşağıdaki konuda bir blog yazısı yaz:

        

        Konu: {topic}

        Ton: {tone}

        Uzunluk: {length_guide.get(length, "1000 kelime")}

        

        Yapı:

        1. Dikkat çekici başlık

        2. Giriş paragrafı

        3. Ana bölümler (alt başlıklarla)

        4. Sonuç

        5. Call-to-action

        

        SEO için anahtar kelimeleri doğal şekilde yerleştir.

        """

        

        response = self.model.generate_content(prompt)

        return response.text

    

    def generate_social_media(self, topic, platform, count=5):

        platform_guides = {

            "twitter": "280 karakter limit, hashtag kullan, kısa ve etkili",

            "instagram": "Emoji kullan, hashtag kullan, görsel odaklı açıklama",

            "linkedin": "Profesyonel ton, değer odaklı, network building",

            "facebook": "Samimi ton, soru sor, etkileşim odaklı"

        }

        

        prompt = f"""

        Aşağıdaki konu için {count} adet {platform} paylaşımı oluştur:

        

        Konu: {topic}

        Platform kuralları: {platform_guides.get(platform, "")}

        

        Her paylaşımı numaralandır ve aralarına --- koy.

        """

        

        response = self.model.generate_content(prompt)

        return response.text.split("---")

    

    def generate_email(self, purpose, recipient, key_points):

        prompt = f"""

        Aşağıdaki bilgilere göre profesyonel bir e-posta yaz:

        

        Amaç: {purpose}

        Alıcı: {recipient}

        Ana noktalar: {key_points}

        

        Format:

        Konu: [Konu satırı]

        

        [E-posta içeriği]

        

        Saygılarımla,

        [İmza yeri]

        """

        

        response = self.model.generate_content(prompt)

        return response.text

    

    def generate_product_description(self, product_name, features, target_audience):

        prompt = f"""

        Aşağıdaki ürün için satış odaklı açıklama yaz:

        

        Ürün: {product_name}

        Özellikler: {features}

        Hedef Kitle: {target_audience}

        

        İçerik:

        1. Dikkat çekici başlık

        2. Kısa özet (2-3 cümle)

        3. Özellikler ve faydalar

        4. Neden bu ürün?

        5. Call-to-action

        

        İkna edici ve dönüşüm odaklı yaz.

        """

        

        response = self.model.generate_content(prompt)

        return response.text

    

    def generate_seo_content(self, keyword, content_type="article"):

        prompt = f"""

        Aşağıdaki anahtar kelime için SEO uyumlu içerik oluştur:

        

        Anahtar Kelime: {keyword}

        İçerik Türü: {content_type}

        

        Dahil et:

        1. SEO başlık (60 karakter)

        2. Meta açıklama (155 karakter)

        3. H1, H2, H3 başlıklar

        4. Anahtar kelime yoğunluğu %2-3

        5. LSI anahtar kelimeler

        6. İç ve dış link önerileri

        

        İçeriği oluştur.

        """

        

        response = self.model.generate_content(prompt)

        return response.text



# Kullanım

generator = ContentGenerator("YOUR_API_KEY")



# Blog yazısı

blog = generator.generate_blog_post(

    topic="Yapay Zeka ve Gelecek",

    tone="informative",

    length="medium"

)

print(blog)



# Sosyal medya

tweets = generator.generate_social_media(

    topic="Python programlama ipuçları",

    platform="twitter",

    count=5

)

for tweet in tweets:

    print(tweet)

Gemini API hata yönetimi şablonu oluştur.



HATA YÖNETİMİ:



import google.generativeai as genai

from google.api_core import exceptions

import time

import logging



logging.basicConfig(level=logging.INFO)

logger = logging.getLogger(__name__)



class GeminiClient:

    def __init__(self, api_key, max_retries=3, retry_delay=1):

        genai.configure(api_key=api_key)

        self.model = genai.GenerativeModel("gemini-pro")

        self.max_retries = max_retries

        self.retry_delay = retry_delay

    

    def generate_with_retry(self, prompt, kwargs):

        last_exception = None

        

        for attempt in range(self.max_retries):

            try:

                response = self.model.generate_content(prompt, kwargs)

                

                # Safety check

                if response.prompt_feedback.block_reason:

                    logger.warning(f"Content blocked: {response.prompt_feedback.block_reason}")

                    return None

                

                return response.text

                

            except exceptions.ResourceExhausted as e:

                # Rate limit

                logger.warning(f"Rate limit hit, attempt {attempt + 1}/{self.max_retries}")

                last_exception = e

                time.sleep(self.retry_delay * (attempt + 1))

                

            except exceptions.InvalidArgument as e:

                # Geçersiz istek - retry etme

                logger.error(f"Invalid argument: {e}")

                raise

                

            except exceptions.DeadlineExceeded as e:

                # Timeout

                logger.warning(f"Timeout, attempt {attempt + 1}/{self.max_retries}")

                last_exception = e

                time.sleep(self.retry_delay)

                

            except Exception as e:

                logger.error(f"Unexpected error: {e}")

                last_exception = e

                time.sleep(self.retry_delay)

        

        raise last_exception or Exception("Max retries exceeded")

    

    def safe_generate(self, prompt, default_response="Yanıt üretilemedi."):

        try:

            result = self.generate_with_retry(prompt)

            return result or default_response

        except Exception as e:

            logger.error(f"Generation failed: {e}")

            return default_response



# Rate limiter

from threading import Lock

from collections import deque



class RateLimiter:

    def __init__(self, max_requests=60, time_window=60):

        self.max_requests = max_requests

        self.time_window = time_window

        self.requests = deque()

        self.lock = Lock()

    

    def acquire(self):

        with self.lock:

            now = time.time()

            

            # Eski istekleri temizle

            while self.requests and self.requests[0] < now - self.time_window:

                self.requests.popleft()

            

            if len(self.requests) >= self.max_requests:

                sleep_time = self.requests[0] - (now - self.time_window)

                if sleep_time > 0:

                    time.sleep(sleep_time)

            

            self.requests.append(now)



# Kullanım

rate_limiter = RateLimiter(max_requests=60, time_window=60)

client = GeminiClient("YOUR_API_KEY")



def generate_safe(prompt):

    rate_limiter.acquire()

    return client.safe_generate(prompt)

Gemini API cache ve optimizasyon şablonu oluştur.



CACHE VE OPTİMİZASYON:



import hashlib

import json

import redis

from functools import wraps



# Redis cache

class GeminiCache:

    def __init__(self, redis_url="redis://localhost:6379", ttl=3600):

        self.redis = redis.from_url(redis_url)

        self.ttl = ttl

    

    def _get_key(self, prompt, params):

        content = json.dumps({"prompt": prompt, "params": params}, sort_keys=True)

        return f"gemini:{hashlib.md5(content.encode()).hexdigest()}"

    

    def get(self, prompt, params=None):

        key = self._get_key(prompt, params or {})

        cached = self.redis.get(key)

        if cached:

            return json.loads(cached)

        return None

    

    def set(self, prompt, response, params=None):

        key = self._get_key(prompt, params or {})

        self.redis.setex(key, self.ttl, json.dumps(response))

    

    def invalidate(self, prompt, params=None):

        key = self._get_key(prompt, params or {})

        self.redis.delete(key)



# Cache decorator

def cached_generate(cache, ttl=3600):

    def decorator(func):

        @wraps(func)

        def wrapper(prompt, *args, kwargs):

            # Cache kontrol

            cached = cache.get(prompt, kwargs)

            if cached:

                return cached

            

            # Generate

            result = func(prompt, *args, **kwargs)

            

            # Cache kaydet

            cache.set(prompt, result, kwargs)

            

            return result

        return wrapper

    return decorator



# In-memory cache (basit)

from functools import lru_cache



@lru_cache(maxsize=100)

def generate_cached(prompt_hash):

    # Bu fonksiyon hash ile çağrılmalı

    pass



# Batch processing

async def batch_generate_optimized(prompts, batch_size=5):

    import asyncio

    

    results = []

    

    for i in range(0, len(prompts), batch_size):

        batch = prompts[i:i + batch_size]

        

        # Paralel işle

        tasks = [

            generate_async(prompt)

            for prompt in batch

        ]

        

        batch_results = await asyncio.gather(*tasks, return_exceptions=True)

        results.extend(batch_results)

        

        # Rate limit için bekle

        await asyncio.sleep(1)

    

    return results



# Token optimizasyonu

def optimize_prompt(prompt, max_tokens=1000):

    words = prompt.split()

    if len(words) > max_tokens:

        # Özetle veya kes

        return " ".join(words[:max_tokens]) + "..."

    return prompt