Kişisel Terminal ChatGPT Botunuzu Python ve OpenAI API’leri ile İnşa Etme ve Dağıtma

Kişisel Terminal ChatGPT Botunuzu Python ve OpenAI API’leri ile İnşa Etme ve Dağıtma

Giriş

Yapay zeka teknolojileri, özellikle büyük dil modelleri (LLM’ler), günlük hayatımızın ve iş süreçlerimizin ayrılmaz bir parçası haline gelmiştir. OpenAI’nin ChatGPT’si gibi platformlar, doğal dil anlama ve üretme yetenekleriyle çığır açmış, insan-bilgisayar etkileşimini yeni bir boyuta taşımıştır. Bu teknolojiler, metin yazımından kod üretimine, bilgi sorgulamadan karmaşık problem çözümlerine kadar geniş bir yelpazede kullanılmaktadır. Ancak, çoğu kullanıcı bu güçlü araçları web arayüzleri veya mobil uygulamalar aracılığıyla deneyimler. Peki ya kendi kişisel, özelleştirilebilir ve tam kontrolünüzde olan bir yapay zeka asistanına sahip olmak isterseniz? Terminal tabanlı bir ChatGPT botu geliştirmek, tam da bu ihtiyacı karşılar.

Bu makalede, Python programlama dilini ve OpenAI API’lerini kullanarak kendi terminal tabanlı ChatGPT botunuzu adım adım nasıl inşa edeceğinizi ve dağıtacağınızı detaylı bir şekilde inceleyeceğiz. Bu süreç, sadece güçlü bir araca sahip olmanızı sağlamakla kalmayacak, aynı zamanda modern yapay zeka API’leriyle çalışma, ortam yönetimi, güvenlik ve dağıtım konularında değerli teknik bilgiler edinmenize de yardımcı olacaktır. Kendi botunuzu geliştirerek, veri gizliliğiniz üzerinde daha fazla kontrol sahibi olacak, botun davranışını tamamen kendi tercihlerinize göre şekillendirebilecek ve hatta maliyetleri daha etkin bir şekilde yönetebileceksiniz.

Bu rehber, hem Python’a yeni başlayanlar hem de deneyimli geliştiriciler için uygundur. Adım adım kod örnekleri, açıklamalar ve en iyi uygulamalarla, kendi yapay zeka asistanınızı hayata geçirme yolculuğunuzda size rehberlik edeceğiz.

Neden Kendi Terminal Botunuzu Geliştirmelisiniz?

Web arayüzleri veya mobil uygulamalar aracılığıyla erişilebilen hazır ChatGPT çözümleri mevcutken, kendi terminal botunuzu geliştirmenin birçok avantajı bulunmaktadır:

Özelleştirme ve Esneklik

Kendi botunuzu oluşturduğunuzda, onun davranışını, yanıt tarzını, kullanacağı modeli ve hatta entegre edeceği ek işlevleri tamamen kontrol edebilirsiniz. Belirli bir alanda uzmanlaşmış bir asistan mı istiyorsunuz? Yoksa belirli bir kodlama dilinde size yardımcı olacak bir partner mi arıyorsunuz? Kendi botunuzla, bu tür özelleştirmeleri kolayca yapabilirsiniz. Prompt mühendisliği ile botunuzun kişiliğini ve amacını belirleyebilir, hatta farklı senaryolar için farklı bot profilleri oluşturabilirsiniz.

Gizlilik ve Veri Kontrolü

Üçüncü taraf uygulamaları kullanırken, verilerinizin nasıl işlendiği ve saklandığı konusunda endişeleriniz olabilir. Kendi terminal botunuzu çalıştırdığınızda, konuşma geçmişinizin ve girdiğiniz verilerin nerede saklanacağını ve nasıl kullanılacağını siz belirlersiniz. Hassas bilgilerle çalışırken veya gizliliğe önem veren projelerde bu, kritik bir avantajdır. API çağrıları OpenAI sunucularına gitse de, verinin yerel olarak nasıl yönetildiği tamamen sizin kontrolünüzdedir.

Öğrenme ve Geliştirme Fırsatı

Bu projeyi geliştirmek, Python programlama, API entegrasyonu, sanal ortam yönetimi, bağımlılık yönetimi, hata ayıklama ve hatta dağıtım gibi birçok alanda pratik deneyim kazanmanızı sağlar. Yapay zeka teknolojilerinin iç işleyişini daha yakından anlamak için harika bir fırsattır. Kendi kodunuzu yazarken karşılaştığınız sorunları çözmek, problem çözme yeteneklerinizi de geliştirecektir.

Hız ve Verimlilik

Terminal tabanlı uygulamalar genellikle web tabanlı arayüzlerden daha hafiftir ve daha hızlı yanıt verebilir. Gereksiz grafik arayüzü yükü olmadan, doğrudan etkileşim kurabilir ve anında yanıtlar alabilirsiniz. Geliştiriciler ve komut satırı kullanıcıları için bu, iş akışına sorunsuz bir entegrasyon anlamına gelir.

Maliyet Kontrolü

OpenAI API’leri kullanım başına ücretlendirilir. Kendi botunuzu geliştirerek, API çağrılarınızın nasıl yapıldığını, hangi modellerin kullanıldığını ve ne kadar token harcandığını daha yakından takip edebilirsiniz. Bu, beklenmedik maliyetlerin önüne geçmenize ve bütçenizi daha iyi yönetmenize yardımcı olabilir. Özellikle token sayımı gibi özellikler ekleyerek, her etkileşimin potansiyel maliyetini önceden görebilirsiniz.

Gerekli Önkoşullar ve Ortam Kurulumu

Kendi terminal botunuzu geliştirmeye başlamadan önce, sisteminizde bazı temel araçların kurulu olması ve belirli bir ortamın hazırlanması gerekmektedir.

Python Kurulumu

Bu proje için Python 3.8 veya daha yeni bir sürüm gereklidir. Python’un sisteminizde kurulu olup olmadığını kontrol etmek için terminalinizde aşağıdaki komutu çalıştırabilirsiniz:

python3 --version

Eğer kurulu değilse veya sürüm eski ise, Python’ın resmi web sitesinden (python.org) işletim sisteminize uygun en güncel sürümü indirebilir ve kurabilirsiniz.

OpenAI API Anahtarı Edinme

OpenAI API’lerini kullanabilmek için bir API anahtarına ihtiyacınız olacak. Bu anahtarı edinmek için aşağıdaki adımları izleyin:

1. OpenAI web sitesine gidin: [platform.openai.com](https://platform.openai.com/).
2. Bir hesap oluşturun veya mevcut hesabınızla giriş yapın.
3. Sağ üst köşedeki profil simgenize tıklayın ve “View API keys” (API anahtarlarını görüntüle) seçeneğini seçin.
4. “Create new secret key” (Yeni gizli anahtar oluştur) düğmesine tıklayın.
5. Oluşturulan anahtarı kopyalayın. Bu anahtarı bir daha göremeyeceğiniz için güvenli bir yere kaydettiğinizden emin olun. Bu anahtar, API’ye erişim kimliğinizdir ve gizli tutulmalıdır.

Sanal Ortam Oluşturma ve Etkinleştirme

Python projelerinde bağımlılıkları yönetmek için sanal ortamlar (virtual environments) kullanmak iyi bir pratiktir. Bu, projenizin bağımlılıklarının sisteminizdeki diğer Python projeleriyle çakışmasını engeller.

Projeniz için bir dizin oluşturun ve içine girin:

mkdir my_chatgpt_bot
cd my_chatgpt_bot

Şimdi bir sanal ortam oluşturun:

python3 -m venv venv

Sanal ortamı etkinleştirin:

* Linux/macOS:

source venv/bin/activate

* Windows (Command Prompt):

venv\Scripts\activate.bat

* Windows (PowerShell):

venv\Scripts\Activate.ps1

Sanal ortam etkinleştirildiğinde, terminal istemcinizin başında (venv) gibi bir ibare göreceksiniz.

Gerekli Kütüphanelerin Kurulumu

Sanal ortamınız etkinleştirildikten sonra, projemiz için gerekli Python kütüphanelerini kurabiliriz:

* openai: OpenAI API’leriyle etkileşim kurmak için resmi Python istemci kütüphanesi.
* python-dotenv: API anahtarınızı ve diğer hassas bilgileri ortam değişkenleri aracılığıyla güvenli bir şekilde yönetmek için.

pip install openai python-dotenv

Artık tüm önkoşullar tamamlandı ve botunuzu geliştirmeye başlamak için hazırsınız.

Botun Çekirdek Mantığını Oluşturma

Kişisel terminal ChatGPT botunuzun kalbi, OpenAI API’leri ile etkileşim kuran Python kodunda yatmaktadır. Bu bölümde, botun temel işlevselliğini adım adım nasıl oluşturacağımızı inceleyeceğiz.

OpenAI API ile Etkileşim

OpenAI API’leri, büyük dil modellerine programatik olarak erişmenizi sağlar. openai Python kütüphanesi, bu etkileşimi oldukça basitleştirir. Özellikle chat.completions endpoint’i, ChatGPT tarzı sohbet deneyimleri için tasarlanmıştır.

Bir sohbet tamamlama isteği gönderirken, API’ye bir model (örneğin, “gpt-3.5-turbo” veya “gpt-4”) ve bir messages listesi sağlamanız gerekir. messages listesi, sohbetin geçmişini temsil eden bir dizi sözlükten oluşur. Her sözlük, bir role (rol) ve content (içerik) içerir.

* system: Botun genel davranışını veya kişiliğini tanımlayan başlangıç mesajı.
* user: Kullanıcının gönderdiği mesajlar.
* assistant: Botun verdiği yanıtlar.

İşte temel bir API etkileşimi örneği:

import os
from openai import OpenAI
from dotenv import load_dotenv

.env dosyasından ortam değişkenlerini yükle
load_dotenv()

OpenAI istemcisini API anahtarı ile başlat
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def get_chat_response(messages, model="gpt-3.5-turbo"):
    """
    OpenAI API'sine bir sohbet isteği gönderir ve yanıtı döndürür.
    """
    try:
        response = client.chat.completions.create(
            model=model,
            messages=messages,
            temperature=0.7, # Yaratıcılık seviyesi (0.0 - 1.0)
            max_tokens=500 # Yanıtın maksimum uzunluğu
        )
        return response.choices[0].message.content
    except Exception as e:
        print(f"API isteği sırasında bir hata oluştu: {e}")
        return "Üzgünüm, şu anda yanıt veremiyorum."

Örnek kullanım:
if __name__ == "__main__":
    conversation_history = [
        {"role": "system", "content": "Sen yardımcı bir yapay zeka asistanısın."},
        {"role": "user", "content": "Merhaba, nasılsın?"}
    ]
    response_content = get_chat_response(conversation_history)
    print(f"Bot: {response_content}")

Bu kod parçacığı, get_chat_response adında bir fonksiyon tanımlar. Bu fonksiyon, verilen mesaj geçmişini kullanarak OpenAI API’sine bir istek gönderir ve botun yanıtını döndürür. temperature parametresi, botun yanıtlarının ne kadar yaratıcı veya rastgele olacağını kontrol eder (daha yüksek değerler daha yaratıcı yanıtlar üretir). max_tokens ise botun üretebileceği maksimum token sayısını belirler.

API Anahtarını Güvenli Yönetme

API anahtarlarınızı doğrudan kodunuzun içine yazmak veya bir metin dosyasına kaydetmek güvenlik açısından risklidir. Bu anahtarların ifşa olması durumunda, hesabınız kötüye kullanılabilir ve yüksek maliyetlerle karşılaşabilirsiniz. Bu nedenle, API anahtarlarını ortam değişkenleri aracılığıyla yönetmek en iyi uygulamadır. python-dotenv kütüphanesi bu süreci kolaylaştırır.

Projenizin kök dizininde .env adında bir dosya oluşturun ve içine API anahtarınızı aşağıdaki formatta ekleyin:

OPENAI_API_KEY="sizin_openai_api_anahtarınız_buraya"

Ardından, Python kodunuzda load_dotenv() fonksiyonunu çağırarak bu değişkenleri ortamınıza yükleyebilirsiniz. Daha sonra os.getenv() kullanarak anahtara erişebilirsiniz. Yukarıdaki örnek kodda bu kullanım zaten gösterilmiştir. .env dosyasını git gibi versiyon kontrol sistemlerine eklememeye özen gösterin (genellikle .gitignore dosyasına eklenir).

Konuşma Geçmişini Yönetme (Statefulness)

ChatGPT gibi sohbet botlarının en önemli özelliklerinden biri, önceki konuşmaları hatırlayabilme yeteneğidir. Bu “statefulness” (durum bilgisi) özelliği, messages listesini her yeni mesajda güncelleyerek sağlanır. Bot, her yeni kullanıcı girdisi aldığında, tüm konuşma geçmişini (sistem mesajı, önceki kullanıcı mesajları ve bot yanıtları) API’ye gönderir. Bu sayede model, bağlamı koruyarak tutarlı ve ilgili yanıtlar üretebilir.

# ... (önceki kodlar) ...

def main():
    # Konuşma geçmişini tutacak liste
    conversation_history = [
        {"role": "system", "content": "Sen yardımcı ve bilgili bir yapay zeka asistanısın. Kullanıcı sorularına detaylı ve açıklayıcı yanıtlar ver."},
    ]

    print("Kişisel Terminal ChatGPT Botunuza hoş geldiniz!")
    print("Çıkmak için 'çıkış' yazın veya sohbeti sıfırlamak için 'sıfırla' yazın.")

    while True:
        user_input = input("\nSiz: ")

        if user_input.lower() == "çıkış":
            print("Güle güle!")
            break
        elif user_input.lower() == "sıfırla":
            conversation_history = [
                {"role": "system", "content": "Sen yardımcı ve bilgili bir yapay zeka asistanısın. Kullanıcı sorularına detaylı ve açıklayıcı yanıtlar ver."},
            ]
            print("Sohbet geçmişi sıfırlandı.")
            continue
        
        # Kullanıcı mesajını geçmişe ekle
        conversation_history.append({"role": "user", "content": user_input})

        # API'den yanıt al
        bot_response = get_chat_response(conversation_history)
        print(f"Bot: {bot_response}")

        # Bot yanıtını geçmişe ekle
        conversation_history.append({"role": "assistant", "content": bot_response})

if __name__ == "__main__":
    main()

Bu main fonksiyonu, sürekli bir döngü içinde kullanıcıdan girdi alır. Kullanıcının mesajını conversation_history listesine user rolüyle ekler, ardından get_chat_response fonksiyonunu çağırarak API’den yanıt alır. Gelen yanıtı ekrana yazdırır ve aynı zamanda assistant rolüyle conversation_history listesine ekler. Bu sayede bir sonraki API çağrısında, tüm konuşma geçmişi modele gönderilir.

Kullanıcı Girişi ve Çıkışı

Terminal tabanlı bir bot için kullanıcı girişi input() fonksiyonu, botun yanıtları ise print() fonksiyonu ile yönetilir. Yukarıdaki main fonksiyonu bu temel etkileşimi göstermektedir. Kullanıcının “çıkış” yazması durumunda döngü sonlanır, “sıfırla” yazması durumunda ise sohbet geçmişi başlangıç sistem mesajına geri döner. Bu basit mekanizmalar, kullanıcı dostu bir terminal deneyimi için yeterlidir.

Gelişmiş Özellikler ve İyileştirmeler

Temel bot işlevselliğini oluşturduktan sonra, kullanıcı deneyimini zenginleştirmek ve botunuzu daha sağlam hale getirmek için çeşitli gelişmiş özellikler ekleyebilirsiniz.

Akışlı Yanıtlar (Streaming Responses)

Varsayılan olarak, OpenAI API’si tüm yanıtı tek bir blok halinde gönderir. Bu, uzun yanıtlar için kullanıcının botun yazmasını beklemesi gerektiği anlamına gelir. Akışlı yanıtlar (streaming responses) kullanarak, botun yanıtını kelime kelime veya cümle cümle alabilir ve terminale yazdırabilirsiniz. Bu, daha dinamik ve hızlı bir kullanıcı deneyimi sağlar.

client.chat.completions.create metoduna stream=True parametresini ekleyerek akışlı yanıtları etkinleştirebilirsiniz.

# ... (önceki importlar ve client tanımı) ...

def get_streaming_chat_response(messages, model="gpt-3.5-turbo"):
    """
    OpenAI API'sine akışlı bir sohbet isteği gönderir ve yanıtı akış halinde döndürür.
    """
    full_response_content = ""
    try:
        stream = client.chat.completions.create(
            model=model,
            messages=messages,
            temperature=0.7,
            stream=True
        )
        print("Bot: ", end="", flush=True) # Yanıtı aynı satırda başlat
        for chunk in stream:
            if chunk.choices[0].delta.content is not None:
                print(chunk.choices[0].delta.content, end="", flush=True)
                full_response_content += chunk.choices[0].delta.content
        print() # Yeni satıra geç
        return full_response_content
    except Exception as e:
        print(f"\nAPI isteği sırasında bir hata oluştu: {e}")
        return "Üzgünüm, şu anda yanıt veremiyorum."

main fonksiyonunda get_chat_response yerine get_streaming_chat_response kullanın:
bot_response = get_streaming_chat_response(conversation_history)

Bu değişiklik, botun yanıtlarını daha etkileşimli hale getirecektir. end="" ve flush=True parametreleri, print fonksiyonunun çıktıyı hemen ve yeni bir satıra geçmeden yazmasını sağlar.

Yapılandırma Dosyası Kullanımı

Model adı, sıcaklık (temperature), maksimum token sayısı gibi ayarları kodun içine gömmek yerine, ayrı bir yapılandırma dosyasında (örneğin, config.ini veya config.json) tutmak esnekliği artırır. Bu, kodda değişiklik yapmadan botun davranışını ayarlamanıza olanak tanır.

Örnek config.ini dosyası:

[openai]
model=gpt-3.5-turbo
temperature=0.7
max_tokens=1000

Python kodunuzda bu ayarları okumak için configparser kütüphanesini kullanabilirsiniz:

import configparser

config = configparser.ConfigParser()
config.read('config.ini')

OPENAI_MODEL = config['openai'].get('model', 'gpt-3.5-turbo')
OPENAI_TEMPERATURE = float(config['openai'].get('temperature', 0.7))
OPENAI_MAX_TOKENS = int(config['openai'].get('max_tokens', 500))

get_chat_response veya get_streaming_chat_response fonksiyonlarında bu değişkenleri kullanın
model=OPENAI_MODEL, temperature=OPENAI_TEMPERATURE, max_tokens=OPENAI_MAX_TOKENS

Hata Yönetimi

API çağrıları sırasında ağ sorunları, API anahtarı hataları, kota aşımları veya geçersiz istekler gibi çeşitli hatalar meydana gelebilir. Bu hataları düzgün bir şekilde yönetmek, botunuzun daha sağlam olmasını sağlar ve kullanıcıya bilgilendirici geri bildirimler sunar. try-except blokları kullanarak potansiyel hataları yakalayabilir ve işleyebilirsiniz.

Yukarıdaki get_chat_response ve get_streaming_chat_response fonksiyonlarında basit bir try-except bloğu zaten mevcuttur. Daha spesifik hataları yakalamak için openai.APIError, openai.RateLimitError gibi istisnaları kullanabilirsiniz.

from openai import OpenAI, APIError, RateLimitError

... (client tanımı) ...

def get_chat_response_robust(messages, model="gpt-3.5-turbo"):
    try:
        response = client.chat.completions.create(
            model=model,
            messages=messages,
            temperature=0.7,
            max_tokens=500
        )
        return response.choices[0].message.content
    except RateLimitError:
        print("API kullanım limitinize ulaştınız. Lütfen bir süre bekleyin veya limitlerinizi kontrol edin.")
        return "Üzgünüm, çok fazla istek gönderdim. Lütfen biraz bekleyin."
    except APIError as e:
        print(f"OpenAI API hatası: {e}")
        return "OpenAI API'sinden bir hata aldım. Lütfen daha sonra tekrar deneyin."
    except Exception as e:
        print(f"Beklenmeyen bir hata oluştu: {e}")
        return "Bir sorun oluştu. Lütfen tekrar deneyin."

Maliyet Kontrolü ve Token Kullanımı

OpenAI API’leri, kullanılan token sayısına göre ücretlendirilir. Her API isteği, hem girdi (prompt) hem de çıktı (completion) için token harcar. Maliyetleri izlemek ve yönetmek için tiktoken kütüphanesini kullanarak mesajlardaki token sayısını tahmin edebilirsiniz.

import tiktoken

def num_tokens_from_messages(messages, model="gpt-3.5-turbo"):
    """
    Mesaj listesindeki token sayısını döndürür.
    """
    try:
        encoding = tiktoken.encoding_for_model(model)
    except KeyError:
        encoding = tiktoken.get_encoding("cl100k_base")
    
    num_tokens = 0
    for message in messages:
        # Her mesaj için 3 token başlangıç maliyeti (rol, içerik, vs.)
        num_tokens += 3 
        for key, value in message.items():
            num_tokens += len(encoding.encode(value))
            if key == "name":
                num_tokens += 1 # Her isim için ek token
    num_tokens += 3 # Yanıt için ek token
    return num_tokens

main fonksiyonunda token kullanımını izleme örneği:
...
conversation_history.append({"role": "user", "content": user_input})
tokens_used_for_prompt = num_tokens_from_messages(conversation_history, model=OPENAI_MODEL)
print(f"Prompt için tahmini token sayısı: {tokens_used_for_prompt}")
# bot_response = get_streaming_chat_response(conversation_history, model=OPENAI_MODEL)
...
conversation_history.append({"role": "assistant", "content": bot_response})
tokens_used_for_completion = num_tokens_from_messages([{"role": "assistant", "content": bot_response}], model=OPENAI_MODEL) - 3 # Sadece completion
print(f"Completion için tahmini token sayısı: {tokens_used_for_completion}")
print(f"Toplam tahmini token sayısı: {tokens_used_for_prompt + tokens_used_for_completion}")

Bu fonksiyon, bir mesaj listesinin yaklaşık token maliyetini hesaplamanıza yardımcı olur. Bu bilgiyi kullanıcıya sunarak veya belirli bir token limitine ulaşıldığında sohbet geçmişini kısaltarak maliyetleri yönetebilirsiniz.

Özel Komutlar ve İşlevsellik

Botunuza /exit, /reset, /help gibi özel komutlar ekleyerek kullanıcı deneyimini zenginleştirebilirsiniz. Bu komutlar, kullanıcının botla daha kolay etkileşim kurmasını sağlar. Yukarıdaki main fonksiyonunda çıkış ve sıfırla komutları zaten gösterilmiştir. Daha karmaşık komutlar için kullanıcı girdisini ayrıştırabilir ve belirli fonksiyonları çağırabilirsiniz.

# main fonksiyonunda:
...
if user_input.lower() == "çıkış":
print("Güle güle!")
break
elif user_input.lower() == "sıfırla":
conversation_history = [
{"role": "system", "content": "Sen yardımcı ve bilgili bir yapay zeka asistanısın. Kullanıcı sorularına detaylı ve açıklayıcı yanıtlar ver."},
]
print("Sohbet geçmişi sıfırlandı.")
continue
elif user_input.lower() == "/yardım":
print("Mevcut komutlar: 'çıkış' (botu kapatır), 'sıfırla' (sohbeti sıfırlar), '/yardım' (bu mesajı gösterir).")
continue
...

Botu Dağıtma ve Çalıştırma

Botunuzu geliştirmeyi tamamladıktan sonra, onu çeşitli ortamlarda çalıştırmak isteyebilirsiniz. Bu bölüm, botunuzu yerel olarak çalıştırmaktan Docker ile konteynerleştirmeye kadar farklı dağıtım yaklaşımlarını ele alacaktır.

Yerel Çalıştırma

Botunuzu kendi bilgisayarınızda yerel olarak çalıştırmak en basit yöntemdir. Geliştirme sürecinde zaten bu şekilde çalıştırdınız.

1. Sanal ortamınızı etkinleştirin:

source venv/bin/activate # Linux/macOS
    # veya
    venv\Scripts\activate.bat # Windows CMD

2. Bot betiğinizi çalıştırın:

python my_chat_bot.py # Bot dosyanızın adı

Botunuz terminalinizde çalışmaya başlayacak ve girdi bekleyecektir.

Containerization (Docker ile Dağıtım)

Docker, uygulamaları bağımlılıklarıyla birlikte izole edilmiş “konteynerler” içinde paketlemenize olanak tanıyan bir platformdur. Botunuzu Dockerize etmek, onu farklı ortamlara (başka bir geliştiricinin makinesi, bir sunucu vb.) kolayca taşıyabilmenizi sağlar ve bağımlılık sorunlarını ortadan kaldırır.

Neden Docker?
* İzolasyon: Botunuz, sisteminizdeki diğer uygulamalardan izole edilmiş bir ortamda çalışır.
* Taşınabilirlik: Konteyner imajı, Docker’ın kurulu olduğu her yerde aynı şekilde çalışır.
* Tutarlılık: Geliştirme, test ve üretim ortamları arasında tutarlılık sağlar.

Dockerfile Oluşturma:
Projenizin kök dizininde Dockerfile adında bir dosya oluşturun (uzantısı yok):

# Resmi Python 3.9 slim imajını temel al
FROM python:3.9-slim-buster

Çalışma dizinini ayarla
WORKDIR /app

Bağımlılıkları kopyala ve kur
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

Uygulama kodunu kopyala
COPY . .

Ortam değişkenleri için bir yer tutucu tanımla (güvenlik için doğrudan anahtarı koymayın)
ENV OPENAI_API_KEY=""

Uygulamayı çalıştıracak komut
CMD ["python", "my_chat_bot.py"]

requirements.txt dosyanızın aşağıdaki gibi olduğundan emin olun:

openai
python-dotenv
tiktoken

Bu dosyayı pip freeze > requirements.txt komutuyla oluşturabilirsiniz.

Docker İmajı Oluşturma:
Projenizin kök dizininde, terminalde aşağıdaki komutu çalıştırın:

docker build -t my-chatgpt-bot .

Bu komut, Dockerfile‘ı kullanarak my-chatgpt-bot adında bir Docker imajı oluşturacaktır.

Docker Konteynerini Çalıştırma:
Konteyneri çalıştırmak için API anahtarınızı ortam değişkeni olarak geçirmelisiniz:

docker run -it --rm -e OPENAI_API_KEY="sizin_openai_api_anahtarınız_buraya" my-chatgpt-bot

* -it: İnteraktif terminal oturumu sağlar.
* --rm: Konteyner durduğunda otomatik olarak silinir (geçici çalıştırmalar için kullanışlıdır).
* -e OPENAI_API_KEY="...": API anahtarınızı konteyner içine ortam değişkeni olarak enjekte eder. Bu, anahtarı doğrudan Dockerfile’a yazmaktan çok daha güvenlidir.

Artık botunuz bir Docker konteyneri içinde çalışıyor olacaktır.

Bulut Ortamında Dağıtım (Opsiyonel, Basit VM)

Botunuzu sürekli çalışır durumda tutmak veya uzaktan erişilebilir kılmak isterseniz, bir bulut sanal makinesine (VM) dağıtabilirsiniz. AWS EC2, Google Cloud VM, Azure VM veya DigitalOcean Droplet gibi servisler bu amaçla kullanılabilir.

1. Bir VM Oluşturun: Seçtiğiniz bulut sağlayıcısında küçük bir Linux VM (örneğin Ubuntu) oluşturun.
2. SSH ile Bağlanın: SSH istemcinizi kullanarak VM’nize bağlanın.
3. Gerekli Araçları Kurun: VM üzerinde Python, pip ve isteğe bağlı olarak Docker’ı kurun.

sudo apt update
    sudo apt install python3 python3-pip python3-venv

4. Bot Kodunu VM’ye Kopyalayın: scp veya git clone kullanarak proje kodunuzu VM’ye aktarın.

# scp ile
    scp -r my_chatgpt_bot/ user@your_vm_ip:/home/user/
    # veya git ile
    git clone your_repo_url.git

5. Ortamı Kurun ve Çalıştırın: VM üzerinde sanal ortamı oluşturun, bağımlılıkları kurun ve .env dosyanızı oluşturarak API anahtarınızı ekleyin.

cd my_chatgpt_bot
    python3 -m venv venv
    source venv/bin/activate
    pip install -r requirements.txt
    # .env dosyasını oluşturun ve API anahtarınızı içine yapıştırın
    nano .env

6. Botu Arka Planda Çalıştırın: Botunuzu SSH oturumunuz kapandıktan sonra bile çalışır durumda tutmak için nohup veya tmux/screen gibi araçları kullanabilirsiniz.

# nohup ile
    nohup python3 my_chat_bot.py &
    # Çıktıyı görmek ve durdurmak için:
    # tail -f nohup.out
    # killall python3

Veya Docker ile dağıttıysanız, Docker komutunu kullanın:

docker run -d --name chatgpt-bot -e OPENAI_API_KEY="sizin_anahtarınız" my-chatgpt-bot
    # -d: detach mode, arka planda çalıştırır
    # --name: konteynere isim verir

Bu, botunuzun bulutta sürekli olarak çalışmasını sağlar.

Güvenlik ve En İyi Uygulamalar

Kendi yapay zeka botunuzu geliştirirken ve dağıtırken güvenliği göz önünde bulundurmak kritik öneme sahiptir.

API Anahtarının Gizliliği

* Asla Kodunuza Sabit Kodlamayın: API anahtarınızı doğrudan Python kodunuzun içine yazmaktan kaçının.
* .env Dosyası Kullanın: .env dosyaları ve python-dotenv gibi kütüphanelerle ortam değişkenleri aracılığıyla yönetin.
* .gitignore’a Ekleyin: .env dosyasını versiyon kontrol sistemlerine (Git gibi) asla eklemeyin. .gitignore dosyanıza /.env satırını eklediğinizden emin olun.
* Docker Kullanırken: Anahtarı docker run komutuyla -e parametresiyle geçirin, Dockerfile‘a yazmayın.
* Bulut Ortamında: Bulut sağlayıcınızın gizli yönetim servislerini (AWS Secrets Manager, Azure Key Vault, Google Secret Manager) kullanmayı düşünebilirsiniz.

Veri Gizliliği (Konuşma Geçmişi)

* Hassas Bilgileri Dikkatli İşleyin: Botunuzla paylaştığınız bilgilerin OpenAI sunucularına gönderildiğini unutmayın. Çok hassas kişisel veya şirket verilerini paylaşmaktan kaçının.
* Yerel Depolama: Eğer konuşma geçmişini kalıcı olarak kaydetmek isterseniz, bunu yerel bir dosyada veya güvenli bir veritabanında yapın. Bu verilerin şifrelenmesi ve erişim kontrollerinin sağlanması önemlidir.
* Veri Saklama Politikaları: OpenAI’nin veri kullanım politikalarını inceleyin. Varsayılan olarak, API verileri model eğitimi için kullanılmaz, ancak bu ayarları her zaman kontrol etmekte fayda vardır.

Bağımlılıkların Güncel Tutulması

Kullandığınız tüm Python kütüphanelerini (openai, python-dotenv, tiktoken vb.) düzenli olarak güncelleyin. Güvenlik açıkları veya performans iyileştirmeleri genellikle yeni sürümlerle birlikte gelir.

pip install --upgrade openai python-dotenv tiktoken

Maliyet İzleme

OpenAI hesabınızdaki kullanım panelini düzenli olarak kontrol edin. Beklenmedik maliyet artışlarını erkenden fark etmek için bütçe uyarıları ayarlayın. tiktoken ile yerel token sayımı yaparak da maliyetleri tahmin edebilirsiniz.

Sonuç ve Gelecek Geliştirmeler

Bu makalede, Python ve OpenAI API’lerini kullanarak kendi kişisel terminal ChatGPT botunuzu nasıl geliştireceğinizi ve dağıtacağınızı kapsamlı bir şekilde inceledik. Temel kurulumdan çekirdek mantığına, gelişmiş özelliklerden dağıtım stratejilerine ve güvenlik en iyi uygulamalarına kadar birçok önemli konuyu ele aldık. Kendi botunuzu inşa etmek, sadece güçlü bir araca sahip olmanızı sağlamakla kalmaz, aynı zamanda yapay zeka teknolojileri, programlama ve sistem yönetimi konularında değerli pratik deneyimler kazandırır.

Kişisel terminal botunuz, bilgiye hızlı erişim, kodlama yardımı, metin oluşturma ve daha fazlası için güçlü bir asistan görevi görebilir. Özelleştirme yeteneği sayesinde, onu belirli ihtiyaçlarınıza göre şekillendirebilir ve iş akışınıza sorunsuz bir şekilde entegre edebilirsiniz.

Gelecek Geliştirmeler

Bu bot, daha da ileriye taşınabilecek bir başlangıç noktasıdır. İşte potansiyel gelecek geliştirmeler için bazı fikirler:

* Sesli Giriş/Çıkış: SpeechRecognition ve gTTS (Google Text-to-Speech) gibi kütüphaneleri kullanarak sesli komutları işleyebilir ve botun yanıtlarını sesli olarak duyurabilirsiniz.
* Araç Entegrasyonu (Tool Use/Function Calling): OpenAI’nin “Function Calling” özelliğini kullanarak botunuzu harici araçlarla entegre edebilirsiniz. Örneğin, internetten bilgi arama, hava durumu sorgulama, takvim yönetimi veya kod çalıştırma gibi işlevler ekleyebilirsiniz.
* Kalıcı Konuşma Geçmişi: Konuşma geçmişini yerel bir dosyaya (JSON, SQLite) kaydederek, botu kapattıktan sonra bile önceki sohbetlerinize devam edebilme özelliği ekleyebilirsiniz.
* GUI (Grafik Kullanıcı Arayüzü): Tkinter, PyQt veya Streamlit gibi kütüphanelerle terminal tabanlı botunuza basit bir grafik arayüzü ekleyerek daha geniş bir kullanıcı kitlesine hitap edebilirsiniz.
* Çoklu Model Desteği: Kullanıcının farklı OpenAI modelleri (GPT-4, GPT-3.5-turbo vb.) arasında seçim yapmasına olanak tanıyın.
* Markdown Desteği: Botun yanıtlarını daha okunabilir hale getirmek için terminalde Markdown formatını işleyebilen kütüphaneler kullanın.
* Profil Yönetimi: Farklı roller veya kişilikler için önceden tanımlanmış sistem prompt’ları içeren profiller oluşturun ve kullanıcıların bunlar arasında geçiş yapmasına izin verin.

Yapay zeka teknolojileri hızla gelişmeye devam ederken, kendi kişisel araçlarınızı oluşturma ve onlara hükmetme yeteneği, dijital dünyada giderek daha değerli hale gelmektedir. Bu proje, bu yolculukta önemli bir adımdır. Kendi botunuzu geliştirmenin keyfini çıkarın!