GPT-4 ile Metin Üretme: Sistem Promptu ve Parametre Ayarları
OpenAI API ile çalışmaya başladığınızda ilk fark ettiğiniz şey şu olur: aynı soruyu GPT-4’e farklı şekillerde sorduğunuzda bambaşka cevaplar alıyorsunuz. Bu tesadüf değil. Sistem promptu nasıl yazıldığı, hangi parametrelerin kullanıldığı ve API’ye nasıl istek atıldığı, çıktı kalitesini doğrudan belirliyor. Sysadmin olarak bunu “konfigürasyon yönetimi” gibi düşünebilirsiniz: doğru ayarlarla tutarlı, öngörülebilir sonuçlar alırsınız, yanlış ayarlarla her seferinde farklı bir sürprizle karşılaşırsınız.
OpenAI API’ye Bağlanmak: Temel Kurulum
Başlamadan önce ortamı hazırlayalım. Python ile çalışacağız çünkü OpenAI’nin resmi kütüphanesi en iyi Python desteğini sunuyor.
# Sanal ortam oluştur
python3 -m venv openai-env
source openai-env/bin/activate
# Gerekli paketleri kur
pip install openai python-dotenv
# API anahtarını .env dosyasına kaydet
echo "OPENAI_API_KEY=sk-proj-xxxxxxxxxxxx" > .env
echo ".env" >> .gitignoreAPI anahtarını asla kod içine gömmeyин. .env dosyası kullanmak hem güvenli hem de farklı ortamlar arasında geçiş yaparken kolaylık sağlar. Production ortamında bunu bir secret manager’a (AWS Secrets Manager, HashiCorp Vault gibi) taşımanızı öneririm.
Temel bir istek nasıl görünür:
from openai import OpenAI
from dotenv import load_dotenv
import os
load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
response = client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": "Sen bir Linux sistem yöneticisisin."},
{"role": "user", "content": "Disk kullanımını nasıl izlerim?"}
]
)
print(response.choices[0].message.content)Bu en basit hali. Ama gerçek dünyada işler bu kadar sade değil.
Sistem Promptu: Modelin Davranışını Şekillendiren Temel Araç
Sistem promptu, GPT-4’e “sen kimsin, nasıl davranacaksın, neyi biliyorsun” diye anlattığınız yerdir. Bunu bir sunucunun /etc/environment dosyası gibi düşünebilirsiniz: her şeyden önce yüklenir ve tüm süreci etkiler.
Kötü yazılmış bir sistem promptu:
Sen yardımcı bir asistansın.Bu kadar belirsiz bir tanım, modelin ne yapması gerektiği konusunda size sınırlı kontrol verir. İyi yazılmış bir sistem promptu şöyle görünür:
system_prompt = """
Sen deneyimli bir Linux sistem yöneticisisin. Görevlerin şunlar:
1. Kullanıcının sorduğu teknik soruları net ve adım adım açıkla
2. Kod örneklerini her zaman çalışır halde ver, varsayımsal değil
3. Güvenlik açıklarına dikkat et ve kullanıcıyı uyar
4. Cevaplarını Türkçe ver ama teknik terimler için İngilizce karşılığı parantez içinde ekle
5. Eğer bir komut destructive (veri kaybına yol açabilecek) ise bunu açıkça belirt
Cevap formatın:
- Kısa açıklama (1-2 cümle)
- Adım adım işlemler
- Kod bloğu
- Dikkat edilecekler
Kesinlikle yapma:
- Root password gibi hassas bilgileri sormak
- Üretim ortamında test edilmemiş komutlar önermek
"""Bu yaklaşımda dikkat edin: ne yapması gerektiği, nasıl yapması gerektiği ve ne yapmaması gerektiği ayrı ayrı belirtiliyor. Bu üçlü yapı sistem promptu etkinliğini dramatik şekilde artırır.
Sistem Promptunda Role Definition
GPT-4’ün farklı “kişilikler” almasını sağlayabilirsiniz. Bu özellikle şirket içi araçlar geliştirirken işe yarar:
# Farklı roller için promptlar
roles = {
"security_auditor": """
Sen bir siber güvenlik uzmanısın. Kullanıcının paylaştığı
konfigürasyonları ve kodları güvenlik açısından değerlendir.
Her cevabında risk seviyesini (DÜŞÜK/ORTA/YÜKSEK/KRİTİK) belirt.
OWASP ve CIS Benchmark standartlarını referans al.
""",
"devops_mentor": """
Sen DevOps pratiklerinde uzman bir mentorsun.
Kullanıcıya sadece çözüm değil, çözümün arkasındaki mantığı da açıkla.
CI/CD, Infrastructure as Code ve monitoring konularında yönlendir.
""",
"incident_responder": """
Sen bir incident response uzmanısın. Kullanıcı büyük ihtimalle
aktif bir problem yaşıyor. Kısa, net ve öncelikli adımlar ver.
Önce stabilizasyon, sonra analiz yaklaşımını benimse.
"""
}Parametreler: Çıktıyı İnce Ayar Yapmak
OpenAI API’sinin en çok göz ardı edilen kısmı parametre ayarlarıdır. Çoğu geliştirici default değerlerle çalışır ve “neden tutarsız sonuçlar alıyorum” diye şikayet eder. Parametreleri anlayalım:
temperature: 0 ile 2 arasında bir değer. Modelin “yaratıcılığını” kontrol eder. 0’a yaklaştıkça deterministik (her seferinde aynı cevap), 2’ye yaklaştıkça kaotik olur. Teknik belgeler için 0.1-0.3, yaratıcı içerik için 0.7-1.0 önerilir.
max_tokens: Cevabın maksimum uzunluğu. Dikkat: bu input token’larını saymaz, sadece output’u sınırlar. Çok düşük ayarlarsanız cevap yarıda kesilir.
top_p: Temperature’a alternatif bir sampling yöntemi. İkisini aynı anda kullanmayın. Temperature kullanıyorsanız top_p’yi 1’de bırakın.
frequency_penalty: -2 ile 2 arasında. Pozitif değerler modelin aynı kelimeleri tekrar kullanmasını azaltır. Uzun metinlerde tekrara düşmemek için kullanışlı.
presence_penalty: Yeni konulara geçişi teşvik eder. Brainstorming oturumları için işe yarar.
n: Kaç farklı cevap üretileceği. API maliyetini n katına çıkarır, dikkatli kullanın.
stop: Modelin duracağı string veya string listesi. Özel output formatları için kritik.
def create_technical_response(user_query, strict_mode=True):
"""
Teknik sysadmin sorularına tutarlı cevaplar için optimize edilmiş fonksiyon
"""
temperature = 0.1 if strict_mode else 0.5
response = client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_query}
],
temperature=temperature,
max_tokens=1500,
top_p=1,
frequency_penalty=0.3,
presence_penalty=0,
stop=["---END---"] # Özel bir bitiş işareti
)
return response.choices[0].message.contentGerçek Dünya Senaryosu 1: Log Analiz Asistanı
Elimde yüzlerce satır log var ve anlamlı bilgi çıkarmak istiyorum. GPT-4’ü log analiz asistanı olarak kullanalım:
import re
from openai import OpenAI
def analyze_logs(log_content, log_type="nginx"):
"""
Log içeriğini GPT-4 ile analiz et
"""
# Log'u kısalt - çok uzun içerik token limitini aşar
log_sample = log_content[:3000] if len(log_content) > 3000 else log_content
system_prompt = f"""
Sen bir {log_type} log analiz uzmanısın.
Verilen log içeriğini analiz et ve şu formatta çıktı ver:
ÖZET: (2-3 cümle genel durum)
KRİTİK HATALAR:
- Her hata için: Hata mesajı | Olası neden | Önerilen aksiyon
UYARILAR:
- Dikkat gerektiren ama kritik olmayan durumlar
PERFORMANS:
- Response time anomalileri
- Yoğun istek dönemleri
TAVSİYELER:
- Uzun vadeli iyileştirme önerileri
"""
response = client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": f"Şu logları analiz et:nn{log_sample}"}
],
temperature=0.1, # Log analizi için düşük temperature
max_tokens=2000
)
return response.choices[0].message.content
# Kullanım
with open("/var/log/nginx/error.log", "r") as f:
log_data = f.read()
analysis = analyze_logs(log_data, "nginx")
print(analysis)Gerçek Dünya Senaryosu 2: Konuşma Geçmişiyle Çalışmak
GPT-4 stateless bir modeldir, yani her isteği bağımsız değerlendirir. Bağlamı siz taşımak zorundasınız. Sysadmin asistanı için bir konuşma yöneticisi yapalım:
class SysAdminAssistant:
def __init__(self, role="general"):
self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
self.conversation_history = []
self.system_prompt = self._get_system_prompt(role)
self.token_limit = 6000 # Güvenli taraf için limit
def _get_system_prompt(self, role):
return f"""
Sen deneyimli bir Linux/Windows sistem yöneticisisin.
Her oturumda kullanıcının sorularını takip et ve önceki
konuşmaya referans ver. Eğer kullanıcı daha önce bahsettiği
bir sistemi tekrar soruyorsa, önceki bağlamı kullan.
Konuşma boyunca tutarlı tavsiyeler ver. Çelişkili öneriler yapma.
"""
def _trim_history(self):
"""Konuşma geçmişini token limitinin altında tut"""
# Basit yaklaşım: eski mesajları at
while len(str(self.conversation_history)) > self.token_limit:
if len(self.conversation_history) > 2:
self.conversation_history.pop(0)
else:
break
def chat(self, user_message):
self.conversation_history.append({
"role": "user",
"content": user_message
})
self._trim_history()
messages = [
{"role": "system", "content": self.system_prompt}
] + self.conversation_history
response = self.client.chat.completions.create(
model="gpt-4",
messages=messages,
temperature=0.2,
max_tokens=1000
)
assistant_message = response.choices[0].message.content
self.conversation_history.append({
"role": "assistant",
"content": assistant_message
})
return assistant_message
# Kullanım
assistant = SysAdminAssistant()
print(assistant.chat("Nginx'i nasıl kurarım?"))
print(assistant.chat("SSL sertifikası da eklemek istiyorum"))
# Bu noktada model nginx bağlamını biliyor
print(assistant.chat("Performans optimizasyonu için ne yapmalıyım?"))Token Yönetimi ve Maliyet Optimizasyonu
Token yönetimi hem performans hem de maliyet açısından kritik. GPT-4 için yaklaşık olarak: 1000 token = 750 İngilizce kelime = 500-600 Türkçe kelime. Türkçe, İngilizce’den daha fazla token tüketir.
import tiktoken
def count_tokens(text, model="gpt-4"):
"""
API çağrısı yapmadan token sayısını hesapla
"""
encoder = tiktoken.encoding_for_model(model)
tokens = encoder.encode(text)
return len(tokens)
def estimate_cost(input_tokens, output_tokens, model="gpt-4"):
"""
Tahmini maliyet hesapla (fiyatlar değişkendir, güncel tutun)
"""
pricing = {
"gpt-4": {"input": 0.03, "output": 0.06}, # per 1K tokens
"gpt-4-turbo": {"input": 0.01, "output": 0.03},
"gpt-3.5-turbo": {"input": 0.0005, "output": 0.0015}
}
if model not in pricing:
return "Bilinmeyen model"
input_cost = (input_tokens / 1000) * pricing[model]["input"]
output_cost = (output_tokens / 1000) * pricing[model]["output"]
return {
"input_cost": f"${input_cost:.4f}",
"output_cost": f"${output_cost:.4f}",
"total": f"${(input_cost + output_cost):.4f}"
}
# Kullanım
system = "Sen bir Linux uzmanısın..."
user_msg = "Disk I/O performansını nasıl izlerim?"
input_tokens = count_tokens(system + user_msg)
print(f"Tahmini input token: {input_tokens}")
print(f"Tahmini maliyet: {estimate_cost(input_tokens, 500)}")Hata Yönetimi ve Rate Limiting
Production ortamında API çağrıları her zaman sorunsuz gitmez. Rate limit aşımı, timeout ve geçici servis kesintileri için dayanıklı bir yapı kurun:
import time
import random
from openai import OpenAI, RateLimitError, APITimeoutError, APIConnectionError
def robust_api_call(messages, max_retries=3, base_delay=1):
"""
Exponential backoff ile güvenilir API çağrısı
"""
for attempt in range(max_retries):
try:
response = client.chat.completions.create(
model="gpt-4",
messages=messages,
temperature=0.2,
max_tokens=1000,
timeout=30 # 30 saniye timeout
)
return response.choices[0].message.content
except RateLimitError as e:
if attempt == max_retries - 1:
raise
# Rate limit için daha uzun bekle
wait_time = base_delay * (2 ** attempt) + random.uniform(0, 1)
print(f"Rate limit aşıldı. {wait_time:.1f} saniye bekleniyor...")
time.sleep(wait_time)
except APITimeoutError:
if attempt == max_retries - 1:
raise
print(f"Timeout. Deneme {attempt + 1}/{max_retries}")
time.sleep(base_delay)
except APIConnectionError as e:
print(f"Bağlantı hatası: {e}")
raise
return None
# Batch işlemler için rate limiting
def process_batch(items, delay_between=0.5):
"""
Birden fazla öğeyi işlerken rate limit'e takılmamak için
"""
results = []
for i, item in enumerate(items):
print(f"İşleniyor: {i+1}/{len(items)}")
result = robust_api_call([
{"role": "system", "content": "Sistem yöneticisi asistanı"},
{"role": "user", "content": item}
])
results.append(result)
# Son eleman değilse bekle
if i < len(items) - 1:
time.sleep(delay_between)
return resultsÇıktı Formatını Kontrol Etmek: JSON Mode
GPT-4’ten yapılandırılmış veri almanız gerekiyorsa, örneğin bir monitoring scripti sonuçlarını parse edecekseniz, JSON mode kullanın:
import json
def get_structured_analysis(server_metrics):
"""
Sunucu metriklerini yapılandırılmış JSON olarak analiz et
"""
response = client.chat.completions.create(
model="gpt-4-turbo-preview", # JSON mode için turbo gerekli
messages=[
{
"role": "system",
"content": """
Verilen sunucu metriklerini analiz et ve şu JSON formatında döndür:
{
"durum": "normal|uyarı|kritik",
"cpu_yorumu": "açıklama",
"memory_yorumu": "açıklama",
"disk_yorumu": "açıklama",
"acil_aksiyon": true/false,
"oneriler": ["öneri1", "öneri2"]
}
"""
},
{
"role": "user",
"content": f"Metrikleri analiz et: {json.dumps(server_metrics)}"
}
],
response_format={"type": "json_object"},
temperature=0.1
)
result = json.loads(response.choices[0].message.content)
return result
# Test
metrics = {
"cpu_percent": 87,
"memory_percent": 92,
"disk_percent": 45,
"load_average": [8.5, 7.2, 6.1]
}
analysis = get_structured_analysis(metrics)
print(f"Durum: {analysis['durum']}")
print(f"Acil aksiyon gerekli: {analysis['acil_aksiyon']}")
if analysis['acil_aksiyon']:
for oneri in analysis['oneriler']:
print(f" - {oneri}")Sistem Promptu Geliştirme: İteratif Yaklaşım
İyi bir sistem promptu ilk denemede ortaya çıkmaz. Ben şu döngüyü takip ediyorum:
- Test koleksiyonu oluştur: 20-30 temsili soru listesi yap. Kolay olanlar değil, gerçekten zorlu edge case’ler.
- Çıktıyı değerlendir: Her soruya verilen cevabı puanla. Format doğru mu? Teknik olarak doğru mu? Güvenli mi?
- Başarısız olan pattern’leri bul: Hangi tür sorularda prompt yetersiz kalıyor?
- Prompt’a kural ekle: Tespit ettiğin sorunu çözen bir kural veya örnek ekle.
- Regresyon testi: Yeni kuralın eski çalışan soruları bozmadığını kontrol et.
Bir prompt’a çok fazla kural eklediğinizde model bunları takip etmekte zorlanıyor. Genellikle 10-15 kural optimum nokta. Daha fazlası çakışmalara ve tutarsızlıklara yol açıyor.
Sonuç
GPT-4 ile etkili metin üretimi, sadece API çağrısı yapmaktan ibaret değil. Sistem promptunu bir konfigürasyon dosyası gibi titizlikle yönetmek, parametreleri kullanım senaryosuna göre ayarlamak ve hataları zarif şekilde ele almak gerekiyor. Sysadmin mantığıyla yaklaşırsanız: önce gereksinimleri belirle, test ortamında dene, production’a çıkmadan önce doğrula.
Pratik olarak şu noktaları aklınızda tutun: Teknik ve deterministik işler için temperature’ı düşük tutun (0.1-0.3 arası), sistem promptunu negatif ve pozitif örneklerle zenginleştirin, token maliyetini gözden kaçırmayın ve rate limiting için her zaman retry mekanizması kurun. Bu temeller üzerine inşa ettiğiniz bir LLM entegrasyonu hem güvenilir hem de bakımı kolay olacaktır.