AI Asistanı Oluşturun
Araçları kullanan, bilgi tabanlarını arayan ve görevleri tamamlayan akıllı bir sanal asistan geliştirin — basit konuşmanın çok ötesinde.
Giriş
Bir AI asistanı, chatbotun çok ötesine geçer. Chatbot yalnızca konuşabilirken, asistan araçları kullanabilir, veritabanlarını arayabilir, eylemleri yürütebilir ve dış sistemlerle entegre olarak gerçekten işleri halledebilir.
Bu rehberde, function calling ve retrieval-augmented generation (RAG) ile bir AI asistanı oluşturacaksınız — modern AI geliştirmenin en güçlü iki tekniği.
Chatbot vs. Asistan
Farkı anlamak önemlidir:
- Chatbot — Yalnızca eğitim verilerini kullanarak mesajlara yanıt verir. Soruları cevaplayabilir ve konuşma yapabilir, ancak eylem gerçekleştiremez veya dış bilgilere erişemez.
- AI Asistanı — Araçları (API'ler, veritabanları, dosya sistemleri) kullanabilir, gerçek zamanlı bilgi alabilir, fonksiyonları yürütebilir ve kullanıcı adına eylem gerçekleştirebilir.
💡 Şöyle Düşünün
Chatbot, çok şey bilen ama boş bir odada oturan biriyle konuşmak gibidir. Asistan ise masasında bilgisayar, telefon ve dosya dolabı olan biriyle konuşmak gibidir — bilgi arayabilir ve harekete geçebilir.
Asistan Mimarisi
İyi tasarlanmış bir AI asistanı dört aşamalı bir boru hattını takip eder:
İsteği Anlama
AI, neye ihtiyaç duyulduğunu anlamak için kullanıcının mesajını analiz eder. Bunun basit bir soru mu, araç tabanlı bir görev mi yoksa çok adımlı bir istek mi olduğunu belirler.
Düşünme ve Planlama
AI, hangi araçlara veya veri kaynaklarına ihtiyacı olduğuna karar verir. Karmaşık istekler için görevi daha küçük adımlara böler.
Araçları Çalıştırma
AI, uygun fonksiyonları çağırır — veritabanı arama, API çağrısı, dosya okuma — ve sonuçları toplar.
Yanıt Oluşturma
AI, araç sonuçlarını kendi bilgisiyle birleştirerek net, yardımcı bir yanıt üretir.
Function Calling
Function calling, AI'ın dış sistemlerle etkileşim kurmasını sağlar. Mevcut araçları tanımlarsınız ve AI bunları ne zaman ve nasıl kullanacağına karar verir.
import openai, json, os
from dotenv import load_dotenv
load_dotenv()
client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# Define tools the assistant can use
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a location",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "City name, e.g. Berlin"
}
},
"required": ["location"]
}
}
},
{
"type": "function",
"function": {
"name": "search_database",
"description": "Search the company knowledge base",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Search query"
}
},
"required": ["query"]
}
}
}
]
# Implement the actual functions
def get_weather(location):
# In production, call a real weather API
return {"temp": "18°C", "condition": "Sunny", "location": location}
def search_database(query):
# In production, search your actual database
return {"results": [f"Found info about: {query}"]}Şimdi AI'ın fonksiyon çağırma kararını işleyen mantığı yazalım:
def run_assistant(user_message, conversation_history):
conversation_history.append(
{"role": "user", "content": user_message}
)
response = client.chat.completions.create(
model="gpt-4",
messages=conversation_history,
tools=tools,
tool_choice="auto"
)
message = response.choices[0].message
# Check if the model wants to call a function
if message.tool_calls:
conversation_history.append(message)
for tool_call in message.tool_calls:
fn_name = tool_call.function.name
fn_args = json.loads(tool_call.function.arguments)
# Execute the function
if fn_name == "get_weather":
result = get_weather(**fn_args)
elif fn_name == "search_database":
result = search_database(**fn_args)
conversation_history.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": json.dumps(result)
})
# Get final response with function results
final_response = client.chat.completions.create(
model="gpt-4",
messages=conversation_history
)
return final_response.choices[0].message.content
return message.contentRetrieval-Augmented Generation (RAG)
RAG, asistanınızın yalnızca eğitim verilerinden değil, kendi belgelerinizden soruları yanıtlamasını sağlar. İlgili belge parçalarını bulup AI'ın bağlamına enjekte ederek çalışır.
from openai import OpenAI
client = OpenAI()
def create_embeddings(texts):
"""Convert text chunks into vector embeddings."""
response = client.embeddings.create(
model="text-embedding-3-small",
input=texts
)
return [item.embedding for item in response.data]
def find_relevant_context(query, documents, doc_embeddings):
"""Find the most relevant documents for a query."""
query_embedding = create_embeddings([query])[0]
# Calculate similarity (cosine similarity)
similarities = []
for i, doc_emb in enumerate(doc_embeddings):
similarity = sum(a * b for a, b in zip(query_embedding, doc_emb))
similarities.append((similarity, documents[i]))
# Return top 3 most relevant documents
similarities.sort(reverse=True)
return [doc for _, doc in similarities[:3]]
def ask_with_context(query, context_docs):
"""Ask the AI with retrieved context."""
context = "\n\n".join(context_docs)
response = client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": f"""Answer based on this context:
{context}
If the answer isn't in the context, say so."""},
{"role": "user", "content": query}
]
)
return response.choices[0].message.content✅ Vektör Veritabanı Seçimi
Üretim RAG sistemleri için, burada gösterilen basit bellek içi yaklaşım yerine Pinecone, Weaviate veya ChromaDB gibi özel bir vektör veritabanı kullanın. Bunlar milyonlarca belgeyi verimli bir şekilde işler.
Asistanı Oluşturma
Function calling ve RAG'ı eksiksiz bir asistanda birleştirelim:
class AIAssistant:
def __init__(self, name, system_prompt, tools=None):
self.name = name
self.client = OpenAI()
self.tools = tools or []
self.history = [{"role": "system", "content": system_prompt}]
self.knowledge_base = []
self.kb_embeddings = []
def add_knowledge(self, documents):
"""Add documents to the assistant's knowledge base."""
self.knowledge_base.extend(documents)
self.kb_embeddings = create_embeddings(self.knowledge_base)
def ask(self, question):
"""Process a question with RAG + function calling."""
# Step 1: Retrieve relevant context
context = ""
if self.knowledge_base:
relevant = find_relevant_context(
question, self.knowledge_base, self.kb_embeddings
)
context = "\nRelevant info: " + " | ".join(relevant)
# Step 2: Add context to the question
enhanced_question = question + context
# Step 3: Run through the LLM with tools
return run_assistant(enhanced_question, self.history)
# Usage
assistant = AIAssistant(
name="Company Helper",
system_prompt="You are a helpful company assistant.",
tools=tools
)
assistant.add_knowledge([
"Our office hours are 9 AM to 6 PM CET.",
"We offer free consultations on Tuesdays.",
"Our main product is an AI workspace platform."
])
response = assistant.ask("What are your office hours?")
print(response)Asistanınızı Test Etme
AI asistanları için kapsamlı test esastır. Bu senaryoları test edin:
- Bilgi tabanından yanıtlanması gereken basit sorular.
- Araç kullanımı gerektiren sorular (ör. hava durumu sorguları).
- Hem bilgi alma hem de araç çalıştırma gerektiren çok adımlı istekler.
- Uç durumlar: asistanın kapsamı dışındaki sorular, belirsiz istekler ve eşzamanlı araç çağrıları.
Özet
Güçlü bir AI asistanı oluşturdunuz. Önemli çıkarımlar:
- AI asistanları, chatbotları araçlar, bilgi tabanları ve eylem yetenekleriyle genişletir.
- Function calling, AI'ın dış araçları ve API'leri ne zaman kullanacağına karar vermesini sağlar.
- RAG, asistanın kendi belgelerinizden yüksek doğrulukla soruları yanıtlamasını sağlar.
- Hem bilen hem de yapan asistanlar için function calling ve RAG'ı birleştirin.