Yapay zeka (YZ) ajanları geliştirmek artık hayal değil! Bu kapsamlı rehber ile MongoDB ve LangChain4j kullanarak ilk akıllı YZ ajanı uygulamanızı nasıl oluşturacağınızı adım adım keşfedin. LangChain4j ve MongoDB Atlas Vector Search ile güçlü, akıllı ve ölçeklenebilir bir YZ ajanı inşa etmenin pratik yollarını öğrenin.
Günümüzün hızla değişen dijital dünyasında, işletmelerin ve bireylerin karşılaştığı en büyük zorluklardan biri, büyük veri yığınlarını anlamlandırmak ve bu verilerden değerli içgörüler elde etmektir. İşte tam da bu noktada yapay zeka ajanları devreye giriyor. Peki, nedir bu YZ ajanları ve neden bu kadar popülerler? Temel olarak, bir YZ ajanı, çevresini algılayabilen, bilgi işleyebilen, hedefler belirleyebilen ve bu hedeflere ulaşmak için bağımsız eylemlerde bulunabilen yazılım tabanlı bir varlıktır. Örneğin, bir müşteri hizmetleri ajanı, müşteri sorularını anlayabilir, geçmiş konuşmaları hatırlayabilir ve hatta bir veritabanından bilgi çekerek doğru yanıtlar verebilir.
Bu ajanlar, otomatikleştirilmiş iş süreçlerinden kişiselleştirilmiş kullanıcı deneyimlerine kadar birçok alanda devrim yaratma potansiyeli taşıyor. Ancak bu tür akıllı sistemleri inşa etmek, karmaşık entegrasyonlar, veri yönetimi ve büyük dil modellerinin (LLM) etkin kullanımı gibi çeşitli teknik zorlukları beraberinde getirir. Neyse ki, LangChain4j gibi kütüphaneler ve MongoDB gibi esnek veritabanı çözümleri sayesinde bu süreç artık çok daha erişilebilir hale geldi. Bu makalede, bu güçlü araçları bir araya getirerek kendi YZ ajanı uygulamanızı nasıl geliştireceğinizi adım adım inceleyeceğiz. Amacımız, sadece teorik bilgi vermekle kalmayıp, aynı zamanda gerçek dünya senaryolarına uygulanabilecek pratik örnekler sunarak konuyu derinlemesine kavramanıza yardımcı olmaktır. Hadi gelin, bu heyecan verici yolculuğa birlikte çıkalım ve geleceğin akıllı uygulamalarını inşa etmeye başlayalım!
Temel Taşlar: LangChain4j ve MongoDB Neden Birleşmeli?
Bir yapay zeka ajanı inşa ederken doğru araçları seçmek, projenizin başarısı için kritik öneme sahiptir. Bu bağlamda, LangChain4j ve MongoDB’nin birleşimi, geliştiricilere benzersiz bir güç ve esneklik sunar. Her iki teknoloji de kendi alanında lider olup, birlikte kullanıldıklarında akıllı uygulamalar için sağlam bir temel oluştururlar. Şimdi bu temel taşları daha yakından inceleyelim.
LangChain4j Nedir ve Neden Kullanmalıyız?
LangChain, büyük dil modelleri (LLM’ler) ile çalışan uygulamalar geliştirmeyi kolaylaştıran popüler bir framework’tür. LangChain4j ise bu framework’ün Java dilindeki karşılığıdır. Peki, LangChain4j neden bu kadar önemli? LLM’ler tek başına güçlüdür, ancak gerçek dünya uygulamalarında genellikle bir LLM’den çok daha fazlasına ihtiyaç duyarız. Örneğin, bir LLM’nin sadece genel bilgileri değil, aynı zamanda belirli bir şirketin iç belgelerini de anlaması gerekebilir. Ya da bir e-posta gönderme veya bir veritabanında arama yapma gibi dış araçlarla etkileşim kurabilmesi gerekebilir.
LangChain4j, bu tür gereksinimleri karşılamak için bir dizi soyutlama ve araç sunar. Bunlar arasında:
- Zincirler (Chains): Birden fazla LLM çağrısını veya LLM ile diğer bileşenleri (veri ön işleme, çıktı formatlama vb.) bir araya getirmek için kullanılır. Bu, karmaşık iş akışlarını basitleştirir.
- Ajanlar (Agents): LLM’lerin hangi eylemleri gerçekleştireceğine karar vermesini ve bu eylemleri sıralı bir şekilde yürütmesini sağlar. Ajanlar, tıpkı insanlar gibi araçları kullanabilir (örneğin, bir arama motoru, bir hesap makinesi, bir veritabanı sorgu aracı).
- Hafıza (Memory): Ajanın geçmiş konuşmaları veya etkileşimleri hatırlamasını sağlar. Bu, daha doğal ve bağlamsal sohbetlerin oluşturulması için hayati öneme sahiptir.
- Belge Yükleyiciler ve Bölücüler (Document Loaders & Splitters): PDF’ler, web sayfaları veya diğer veri kaynaklarından bilgileri yüklemeyi ve bunları LLM’lerin işleyebileceği parçalara bölmeyi kolaylaştırır.
- Vektör Depoları (Vector Stores): Belgelerin vektör gömme (embedding) temsillerini depolamak ve anlamsal aramalar yapmak için kullanılır.
Kısacası, LangChain4j, LLM’lerin gerçek dünyadaki veri ve araçlarla sorunsuz bir şekilde etkileşim kurmasını sağlayan bir orkestrasyon katmanı görevi görür. Bu sayede, geliştiriciler sıfırdan her şeyi yazmak yerine, karmaşık YZ uygulamalarını daha hızlı ve daha güvenilir bir şekilde oluşturabilirler.
MongoDB’nin AI Uygulamalarındaki Rolü ve Vektör Araması Nasıl Çalışır?
Yapay zeka uygulamaları genellikle büyük miktarda veriyle çalışır ve bu verinin esnek, ölçeklenebilir ve hızlı bir şekilde depolanması ve sorgulanması gerekir. İşte burada MongoDB devreye giriyor. MongoDB, NoSQL bir veritabanı olup, doküman tabanlı yapısı sayesinde şema esnekliği sunar. Bu, özellikle sürekli değişen veya farklı formatlardaki verilerle çalışan YZ projeleri için büyük bir avantajdır. Örneğin, bir YZ ajanı, kullanıcı etkileşimlerini, özel araç tanımlarını, bağlamsal bilgileri veya hatta LLM çıktılarını tek bir esnek koleksiyonda depolayabilir.
Ancak MongoDB’nin YZ dünyasındaki gerçek gücü, özellikle MongoDB Atlas Vector Search özelliğiyle ortaya çıkar. Geleneksel veritabanı aramaları genellikle anahtar kelime eşleştirmesine dayanırken, vektör araması, verinin anlamsal anlamını dikkate alır. Nasıl mı çalışıyor?
- Gömme (Embedding) Oluşturma: Metin, resim veya diğer veri türleri, özel YZ modelleri (gömme modelleri) kullanılarak yüksek boyutlu sayısal vektörlere dönüştürülür. Bu vektörler, verinin anlamsal anlamını yakalar. Birbirine anlamsal olarak yakın verilerin vektörleri, yüksek boyutlu uzayda birbirine daha yakın konumlanır.
- Vektör Depolama: Bu vektörler, ilişkili verileriyle birlikte MongoDB koleksiyonlarında depolanır.
- Vektör İndeksi: MongoDB Atlas, bu vektörler üzerinde özel bir vektör indeksi (örneğin, HNSW – Hierarchical Navigable Small Worlds) oluşturur. Bu indeks, yüksek boyutlu uzayda komşu vektörleri hızlıca bulmayı sağlar.
- Anlamsal Arama: Bir sorgu geldiğinde, bu sorgu da aynı gömme modeli kullanılarak bir vektöre dönüştürülür. Ardından, MongoDB Atlas Vector Search, bu sorgu vektörüne en yakın depolanmış vektörleri (yani, anlamsal olarak en alakalı verileri) hızlıca bulur ve sonuçları döndürür.
Bu özellik, özellikle LangChain’in RAG (Retrieval-Augmented Generation) deseninde kritik bir rol oynar. RAG, bir LLM’nin sadece kendi öğrendiği bilgilere dayanmak yerine, dış kaynaklardan (bizim durumumuzda MongoDB’den) ilgili bilgileri alıp, bu bilgilerle desteklenerek yanıt üretmesini sağlar. Bu sayede, LLM’ler güncel, doğru ve alan özelinde bilgilere erişebilir, halüsinasyon riskini azaltır ve çok daha güvenilir yanıtlar verebilir.
Dolayısıyla, LangChain4j ile bir YZ ajanı inşa ederken, MongoDB, hem ajanın durumunu, hafızasını ve araç tanımlarını esnek bir şekilde depolamak için mükemmel bir seçimdir, hem de Atlas Vector Search sayesinde ajana özel bir bilgi tabanı sağlayarak RAG deseniyle LLM’in yeteneklerini büyük ölçüde genişletir. Bu sinerji, gerçekten akıllı ve bağlamsal farkındalığa sahip YZ uygulamaları geliştirmenin kapılarını aralar.
Adım Adım İlk AI Ajanımızı Geliştirme: Ön Hazırlıklar ve Kurulum
Artık teorik temelleri anladığımıza göre, ilk yapay zeka ajanımızı inşa etmeye başlayabiliriz. Bu bölümde, geliştirme ortamımızı kuracak, MongoDB Atlas’ı yapılandıracak ve projemizin temel bağımlılıklarını ekleyeceğiz. Bu adımlar, projenizin sağlam bir temele oturmasını sağlayacaktır.
Geliştirme Ortamının Hazırlanması
LangChain4j, Java tabanlı bir kütüphane olduğu için, bir Java geliştirme ortamına ihtiyacımız olacak. İşte başlangıç için gerekenler:
- Java Development Kit (JDK): En az JDK 17 veya üzeri bir sürüm yüklü olmalıdır. OpenJDK veya Oracle JDK kullanabilirsiniz.
- Maven veya Gradle: Proje bağımlılıklarını yönetmek ve derlemek için bir build aracı. Bu örnekte Maven kullanacağız.
- Entegre Geliştirme Ortamı (IDE): IntelliJ IDEA, Eclipse veya VS Code gibi bir IDE, kod yazma ve hata ayıklama sürecini kolaylaştıracaktır.
Kurulumları tamamladıktan sonra, yeni bir Maven projesi oluşturarak başlayabiliriz. Terminalinizde aşağıdaki komutu çalıştırarak basit bir Maven projesi oluşturabilirsiniz:
mvn archetype:generate -DgroupId=com.example -DartifactId=ai-agent -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
Bu komut, ai-agent adında yeni bir dizin oluşturacak ve içerisinde temel bir Maven proje yapısı barındıracaktır.
MongoDB Atlas Kurulumu ve Vektör İndeksi Oluşturma
Veritabanı tarafında, ölçeklenebilir ve yönetilebilir bir çözüm için MongoDB Atlas'ı kullanacağız. Eğer henüz bir hesabınız yoksa, MongoDB Atlas web sitesinden ücretsiz bir hesap oluşturabilirsiniz. Free Tier (ücretsiz katman) çoğu başlangıç projesi için yeterlidir.
- Yeni Bir Küme Oluşturun: Atlas arayüzünde "Build a Database" seçeneğini kullanarak yeni bir küme (cluster) oluşturun. Free Tier seçeneğini (M0 Sandbox) tercih edebilirsiniz. Bulut sağlayıcısını (AWS, GCP, Azure) ve bölgeyi size en yakın olanı seçin.
- Veritabanı Kullanıcısı ve Ağ Erişimi: Güvenlik sekmesinden bir veritabanı kullanıcısı oluşturun ve güçlü bir parola belirleyin. Ayrıca, "Network Access" sekmesinden IP adresinizi beyaz listeye ekleyin veya tüm IP adreslerinden erişime izin verin (geliştirme ortamı için).
- Bağlantı Dizisi (Connection String): Kümeniz hazır olduğunda, "Connect" düğmesine tıklayın ve "Connect your application" seçeneğini seçin. Burada Java için gerekli bağlantı dizisini bulacaksınız. Bu dizeyi kopyalayın, ve kısımlarını kendi bilgilerinizle değiştirin. Şuna benzer görünecektir:
mongodb+srv://:@cluster0.abcde.mongodb.net/?retryWrites=true&w=majority
Şimdi en önemli adımlardan birine geçelim: vektör indeksi oluşturma. Bu indeks, YZ ajanımızın anlamsal aramalar yapmasını sağlayacak. MongoDB Atlas arayüzünde, "Collections" sekmesine gidin. your_database_name.your_collection_name şeklinde yeni bir koleksiyon oluşturun (örneğin, ai_agent_db.documents). Daha sonra, bu koleksiyon üzerinde "Create Search Index" düğmesine tıklayın ve aşağıdaki gibi bir JSON tanımı ile bir vektör indeksi oluşturun. Bu tanım, embedding alanının bir vektör alanı olduğunu ve cosine benzerlik ölçütünün kullanılacağını belirtir.
{
"mappings": {
"dynamic": true,
"fields": {
"embedding": {
"type": "knnVector",
"dimensions": 1536, // Kullandığınız embedding modeline göre boyut değişebilir (örn: OpenAI text-embedding-ada-002 için 1536)
"similarity": "cosine"
}
}
}
}
Vektör indeksinin oluşturulması biraz zaman alabilir. Hazır olduğunda, YZ ajanımız anlamsal aramalar yapmaya hazır olacaktır.
Proje Bağımlılıklarının Eklenmesi
Maven projemizin pom.xml dosyasına gerekli bağımlılıkları eklememiz gerekiyor. Temel olarak LangChain4j, OpenAI entegrasyonu (veya seçtiğiniz başka bir LLM sağlayıcısı) ve MongoDB sürücüsü ile Atlas Vector Search bağımlılıklarına ihtiyacımız olacak.
dev.langchain4j
langchain4j
0.32.0
dev.langchain4j
langchain4j-openai
0.32.0
dev.langchain4j
langchain4j-mongodb
0.32.0
org.mongodb
mongodb-driver-sync
4.11.1
org.slf4j
slf4j-simple
2.0.7
runtime
org.junit.jupiter
junit-jupiter-api
5.10.0
test
Bağımlılıkları ekledikten sonra Maven projenizi güncellemeyi unutmayın (IDE'nizde sağ tıklayıp "Maven -> Reload Project" veya mvn clean install komutunu çalıştırarak). Bu adımlarla, ilk YZ ajanı projenizin temelini sağlam bir şekilde atmış oldunuz. Artık LLM entegrasyonu ve hafıza yönetimi gibi daha ileri konulara geçebiliriz.
AI Ajanı Çekirdeği: LLM Entegrasyonu ve Hafıza Yönetimi
Bir yapay zeka ajanının kalbi, büyük dil modeli (LLM) ve onunla etkileşim kurma yeteneğidir. Ancak bir LLM'yi sadece bir kez sorgulamak, gerçek bir ajanı yeterince akıllı kılmaz. Ajanın geçmiş etkileşimleri hatırlaması ve bağlamı koruması gerekir. Bu bölümde, LLM'yi LangChain4j ile nasıl entegre edeceğimizi ve ajana kalıcı bir hafıza eklemek için MongoDB'yi nasıl kullanacağımızı öğreneceğiz.
Büyük Dil Modelini (LLM) LangChain4j ile Tanıştırmak
LangChain4j, farklı LLM sağlayıcılarıyla kolayca entegre olmanızı sağlar. Bu örnekte OpenAI'ı kullanacağız, ancak Hugging Face, Google Gemini gibi başka modelleri de benzer şekilde entegre edebilirsiniz. OpenAI API anahtarınıza ihtiyacınız olacak.
Öncelikle, OpenAI API anahtarınızı ortam değişkeni olarak ayarlamanız şiddetle tavsiye edilir. Örneğin, Linux/macOS üzerinde:
export OPENAI_API_KEY="sk-YOUR_OPENAI_API_KEY"
Ardından, Java kodunuzda bir OpenAI LLM örneği oluşturabilirsiniz:
import dev.langchain4j.model.openai.OpenAiChatModel;
public class AgentCore {
public static void main(String[] args) {
// OpenAI API anahtarını ortam değişkeninden alır
String openaiApiKey = System.getenv("OPENAI_API_KEY");
if (openaiApiKey == null || openaiApiKey.isEmpty()) {
System.err.println("Hata: OPENAI_API_KEY ortam değişkeni ayarlanmamış.");
return;
}
OpenAiChatModel model = OpenAiChatModel.builder()
.apiKey(openaiApiKey)
.modelName("gpt-4") // veya "gpt-3.5-turbo"
.temperature(0.7) // Yaratıcılık seviyesi (0.0-1.0 arası)
.build();
String userMessage = "Merhaba, nasılsın?";
String aiResponse = model.generate(userMessage);
System.out.println("Kullanıcı: " + userMessage);
System.out.println("AI: " + aiResponse);
// İkinci bir mesaj gönderelim
String userMessage2 = "Bana İstanbul hakkında ilginç bir bilgi verir misin?";
String aiResponse2 = model.generate(userMessage2); // Dikkat: Bu model hafızasızdır.
System.out.println("Kullanıcı: " + userMessage2);
System.out.println("AI: " + aiResponse2);
}
}
Yukarıdaki örnekte model.generate() çağrısı her seferinde yeni bir bağlamla yapılır. Yani LLM, önceki konuşmayı hatırlamaz. Bu noktada ajana hafıza ekleme ihtiyacı ortaya çıkar.
Ajanın Geçmişi Unutmaması İçin Hafıza Ekleme: MongoDB ChatMessageHistory
Bir sohbet robotunun veya akıllı ajanın en önemli özelliklerinden biri, kullanıcıyla yaptığı önceki konuşmaları hatırlayabilmesidir. LangChain4j, bu hafıza yönetimini kolaylaştırmak için ChatMessageHistory arayüzünü sunar. MongoDB entegrasyonu sayesinde, bu sohbet geçmişini kalıcı olarak MongoDB'de saklayabiliriz. Bu sayede, uygulama yeniden başlatılsa bile ajan geçmişi hatırlamaya devam eder.
MongoDB bağlantı dizemizi kullanarak bir MongoClient ve ardından MongoDBChatMessageHistory örneği oluşturmamız gerekecek:
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.SystemMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.store.memory.chat.MongoDBChatMessageHistory;
import static dev.langchain4j.data.message.SystemMessage.systemMessage;
public class AgentWithMemory {
private static final String MONGO_CONNECTION_STRING = "mongodb+srv://:@cluster0.abcde.mongodb.net/?retryWrites=true&w=majority";
private static final String DATABASE_NAME = "ai_agent_db";
private static final String COLLECTION_NAME = "chat_history"; // Sohbet geçmişi için yeni bir koleksiyon
public static void main(String[] args) {
String openaiApiKey = System.getenv("OPENAI_API_KEY");
if (openaiApiKey == null || openaiApiKey.isEmpty()) {
System.err.println("Hata: OPENAI_API_KEY ortam değişkeni ayarlanmamış.");
return;
}
// 1. OpenAI Chat Modeli oluştur
OpenAiChatModel model = OpenAiChatModel.builder()
.apiKey(openaiApiKey)
.modelName("gpt-3.5-turbo")
.temperature(0.7)
.build();
// 2. MongoDB MongoClient oluştur
MongoClient mongoClient = MongoClients.create(MONGO_CONNECTION_STRING);
// 3. MongoDBChatMessageHistory ile kalıcı hafıza oluştur
// 'user123' bir kullanıcı/session ID'si olabilir. Her kullanıcı için ayrı hafıza.
MongoDBChatMessageHistory chatMessageHistory = new MongoDBChatMessageHistory(
mongoClient,
DATABASE_NAME,
COLLECTION_NAME,
"user123" // Kullanıcı kimliği
);
// 4. ChatMemory'yi bu tarihçe ile sarmala
// MessageWindowChatMemory, geçmiş mesajları belli bir pencerede tutar.
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.maxMessages(10) // Son 10 mesajı hatırla
.chatMessageHistory(chatMessageHistory)
.build();
// 5. İlk etkileşim
System.out.println("Kullanıcı: Nasılsın?");
chatMemory.add(UserMessage.from("Nasılsın?")); // Kullanıcı mesajını hafızaya ekle
AiMessage aiResponse1 = model.generate(chatMemory.messages()).content();
chatMemory.add(AiMessage.from(aiResponse1)); // AI cevabını hafızaya ekle
System.out.println("AI: " + aiResponse1);
// 6. İkinci etkileşim - Ajan şimdi önceki konuşmayı hatırlıyor olmalı
System.out.println("\nKullanıcı: Adın neydi?");
chatMemory.add(UserMessage.from("Adın neydi?"));
AiMessage aiResponse2 = model.generate(chatMemory.messages()).content();
chatMemory.add(AiMessage.from(aiResponse2));
System.out.println("AI: " + aiResponse2);
// MongoClient'ı kapatmayı unutmayın
mongoClient.close();
}
}
Bu kod bloğunda, MongoDBChatMessageHistory kullanarak bir chat_history koleksiyonunda user123 kimliğine sahip kullanıcının tüm konuşma geçmişini kalıcı olarak saklıyoruz. MessageWindowChatMemory ise, bu geçmişin sadece son N mesajını LLM'e göndermek için bir pencere görevi görür. Bu, token maliyetini düşürmek ve LLM'in bağlam limitlerini aşmamak için önemlidir.
Bu yapılandırma ile yapay zeka ajanınız artık yalnızca anlık sorgulara yanıt vermekle kalmayacak, aynı zamanda kullanıcıyla devam eden bir diyaloğu sürdürebilecek, geçmiş etkileşimlerini hatırlayabilecek ve daha kişiselleştirilmiş ve tutarlı bir deneyim sunabilecektir. Böylece, ajanın gerçek bir "hafızaya" sahip olmasını sağlamış oluyoruz.
Gerçek Dünya Verileriyle Etkileşim: RAG ve MongoDB Atlas
Yapay zeka ajanlarımızın sadece genel bilgilerle sınırlı kalmasını istemeyiz. Onların, işletmemizin özel verileriyle veya belirli bir alanın derinlemesine bilgileriyle etkileşim kurabilmesi gerekir. İşte burada Retrieval-Augmented Generation (RAG) deseni ve MongoDB Atlas Vector Search'ün gücü devreye giriyor. RAG, LLM'in harici bir bilgi kaynağından (bizim durumumuzda MongoDB) ilgili bilgileri alarak yanıtlarını zenginleştirmesini sağlar. Böylece LLM, halüsinasyon riskini azaltır ve daha doğru, güncel ve bağlamsal yanıtlar üretir.
Bilgi Tabanı Oluşturma ve Vektörleştirme
Bir RAG sisteminde ilk adım, ajanımızın sorgulayacağı bir bilgi tabanı oluşturmaktır. Bu bilgi tabanı, şirket içi dokümanlar, web sayfaları, ürün katalogları veya herhangi bir metinsel veri olabilir. Bu verileri LLM'in anlayabileceği bir formata dönüştürmemiz gerekir: vektör gömmeler (embeddings).
LangChain4j, bu süreci kolaylaştırmak için bir dizi araç sunar:
- Belge Yükleyiciler (Document Loaders): PDF'ler, TXT dosyaları, web sayfaları gibi çeşitli kaynaklardan veriyi yükler.
- Metin Bölücüler (Text Splitters): Yüklenen büyük belgeleri, LLM'in bağlam penceresine sığabilecek ve anlamsal bütünlüğünü koruyacak şekilde daha küçük parçalara (chunks) ayırır.
- Gömme Modelleri (Embedding Models): Bu küçük metin parçalarını sayısal vektörlere dönüştürür.
Şimdi örnek bir kod bloğu ile bu süreci nasıl gerçekleştireceğimize bakalım. Bu örnekte basit bir metin listesinden bir bilgi tabanı oluşturacağız ve bunları MongoDB Atlas'a yükleyeceğiz.
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.loader.FileSystemDocumentLoader;
import dev.langchain4j.data.document.parser.TextDocumentParser;
import dev.langchain4j.data.document.splitter.DocumentSplitters;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.openai.OpenAiEmbeddingModel;
import dev.langchain4j.store.embedding.mongodb.MongoDBAtlasVectorStore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import static java.util.Arrays.asList;
import static dev.langchain4j.data.document.loader.FileSystemDocumentLoader.loadDocument;
public class KnowledgeBaseCreator {
private static final Logger logger = LoggerFactory.getLogger(KnowledgeBaseCreator.class);
private static final String MONGO_CONNECTION_STRING = "mongodb+srv://:@cluster0.abcde.mongodb.net/?retryWrites=true&w=majority";
private static final String DATABASE_NAME = "ai_agent_db";
private static final String COLLECTION_NAME = "documents"; // Bilgi tabanı için koleksiyon
private static final String VECTOR_INDEX_NAME = "vector_index"; // MongoDB Atlas'ta oluşturduğunuz indeks adı
public static void main(String[] args) throws IOException {
String openaiApiKey = System.getenv("OPENAI_API_KEY");
if (openaiApiKey == null || openaiApiKey.isEmpty()) {
logger.error("Hata: OPENAI_API_KEY ortam değişkeni ayarlanmamış.");
return;
}
// 1. Gömme modelini oluştur (OpenAI Embedding modeli)
EmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()
.apiKey(openaiApiKey)
.modelName("text-embedding-ada-002") // Genellikle bu model kullanılır
.build();
// 2. MongoDB Client ve Vector Store oluştur
MongoClient mongoClient = MongoClients.create(MONGO_CONNECTION_STRING);
MongoDBAtlasVectorStore vectorStore = MongoDBAtlasVectorStore.builder()
.mongoClient(mongoClient)
.databaseName(DATABASE_NAME)
.collectionName(COLLECTION_NAME)
.indexName(VECTOR_INDEX_NAME)
.embeddingModel(embeddingModel) // Vector store oluşturulurken embedding modeli belirtilir
.build();
// 3. Bilgi kaynağımızı oluştur (Basit metin dosyası)
// Geçici bir dosya oluşturalım
Path tempFile = Paths.get("temp_knowledge_base.txt");
Files.writeString(tempFile, "İstanbul, Türkiye'nin en kalabalık şehridir ve kültürel bir merkezdir. Boğaz, şehri Asya ve Avrupa olarak ikiye ayırır. Tarihi yarımada, Ayasofya ve Sultanahmet Camii gibi birçok önemli esere ev sahipliği yapar. Türkiye'nin başkenti Ankara'dır, İstanbul değil.");
// 4. Dokümanı yükle ve böl
// FileSystemDocumentLoader.loadDocument(tempFile, new TextDocumentParser()); yerine Files.readString() ile direk metni alıp işleyebiliriz.
// Ancak standart LangChain4j yükleyicilerini kullanmak daha esnektir.
Document document = loadDocument(tempFile, new TextDocumentParser());
List segments = DocumentSplitters.recursive(
100, // Maksimum 100 karakterlik parçalar
0 // Çakışma yok
).split(document);
// 5. Her metin parçasını vektörlere dönüştür ve MongoDB'ye kaydet
// MongoDBAtlasVectorStore, bu işlemi otomatik olarak yapar.
logger.info("Metin parçalarını vektörleştirip MongoDB'ye kaydediyor...");
vectorStore.add(segments);
logger.info("Bilgi tabanı MongoDB'ye başarıyla eklendi.");
// Geçici dosyayı sil
Files.delete(tempFile);
mongoClient.close();
}
}
Bu kod parçası, örnek bir metin belgesini yükler, onu küçük TextSegment'lere böler, OpenAiEmbeddingModel kullanarak her segmentin vektör gömmesini oluşturur ve son olarak bu segmentleri ve ilişkili vektörlerini MongoDBAtlasVectorStore aracılığıyla MongoDB Atlas'a kaydeder. MongoDB Atlas tarafında, embedding alanının knnVector olarak tanımlandığı bir indeksin (önceki adımda oluşturduğumuz gibi) zaten var olduğundan emin olun.
MongoDB Atlas Vector Search ile Akıllı Veri Alımı
Bilgi tabanımız MongoDB'de vektörler olarak depolandığına göre, artık ajanımızın sorgularına yanıt verirken bu bilgi tabanını nasıl kullanacağını yapılandırabiliriz. Bu, RetrievalAugmentor veya doğrudan EmbeddingStoreRetriever kullanımıyla gerçekleşir.
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import dev.langchain4j.chain.ConversationalChain;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiEmbeddingModel;
import dev.langchain4j.retriever.EmbeddingStoreRetriever;
import dev.langchain4j.retriever.Retriever;
import dev.langchain4j.store.embedding.mongodb.MongoDBAtlasVectorStore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class AgentWithRAG {
private static final Logger logger = LoggerFactory.getLogger(AgentWithRAG.class);
private static final String MONGO_CONNECTION_STRING = "mongodb+srv://:@cluster0.abcde.mongodb.net/?retryWrites=true&w=majority";
private static final String DATABASE_NAME = "ai_agent_db";
private static final String DOCS_COLLECTION_NAME = "documents"; // Bilgi tabanı koleksiyonu
private static final String CHAT_HISTORY_COLLECTION_NAME = "chat_history"; // Sohbet geçmişi koleksiyonu
private static final String VECTOR_INDEX_NAME = "vector_index"; // MongoDB Atlas'taki vektör indeks adı
public static void main(String[] args) {
String openaiApiKey = System.getenv("OPENAI_API_KEY");
if (openaiApiKey == null || openaiApiKey.isEmpty()) {
logger.error("Hata: OPENAI_API_KEY ortam değişkeni ayarlanmamış.");
return;
}
MongoClient mongoClient = MongoClients.create(MONGO_CONNECTION_STRING);
// Chat Modeli
ChatLanguageModel chatModel = OpenAiChatModel.builder()
.apiKey(openaiApiKey)
.modelName("gpt-3.5-turbo")
.temperature(0.5)
.build();
// Embedding Modeli
EmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()
.apiKey(openaiApiKey)
.modelName("text-embedding-ada-002")
.build();
// Vektör Deposu (MongoDB Atlas)
MongoDBAtlasVectorStore vectorStore = MongoDBAtlasVectorStore.builder()
.mongoClient(mongoClient)
.databaseName(DATABASE_Name)
.collectionName(DOCS_COLLECTION_NAME)
.indexName(VECTOR_INDEX_NAME)
.embeddingModel(embeddingModel)
.build();
// Retriever oluşturma - En alakalı 3 dokümanı getirir
Retriever retriever = EmbeddingStoreRetriever.from(
vectorStore,
embeddingModel,
3 // En alakalı ilk 3 segmenti getir
);
// Sohbet Hafızası (MongoDB destekli)
dev.langchain4j.store.memory.chat.ChatMessageHistory mongoChatMessageHistory = new dev.langchain4j.store.memory.chat.MongoDBChatMessageHistory(
mongoClient,
DATABASE_NAME,
CHAT_HISTORY_COLLECTION_NAME,
"user456"
);
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.maxMessages(10)
.chatMessageHistory(mongoChatMessageHistory)
.build();
// ConversationalChain oluşturma - RAG'ı ve hafızayı birleştirir
ConversationalChain chain = ConversationalChain.builder()
.chatLanguageModel(chatModel)
.chatMemory(chatMemory)
.retriever(retriever)
// .promptTemplate("Context:\n{{context}}\n\nQuestion: {{question}}\nAnswer:") // İsteğe bağlı, varsayılan şablonu kullanabiliriz
.build();
// Etkileşimler
System.out.println("Kullanıcı: İstanbul hakkında bilgi verir misin?");
String aiResponse1 = chain.execute("İstanbul hakkında bilgi verir misin?");
System.out.println("AI: " + aiResponse1);
System.out.println("\nKullanıcı: Peki Türkiye'nin başkenti neresidir?");
String aiResponse2 = chain.execute("Peki Türkiye'nin başkenti neresidir?");
System.out.println("AI: " + aiResponse2);
mongoClient.close();
}
}
Bu örnekte, EmbeddingStoreRetriever'ı kullanarak kullanıcının sorgusuna anlamsal olarak en yakın belgeleri MongoDBAtlasVectorStore'dan alıyoruz. ConversationalChain ise bu alınan bağlamı, sohbet geçmişini ve LLM'i bir araya getirerek nihai yanıtı üretir. Ajanımız artık sadece genel bilgiye değil, aynı zamanda sizin sağladığınız özel bilgi tabanına da erişebiliyor!
Bu entegrasyonla, YZ ajanınız artık çok daha yetenekli ve "bilgili" hale geliyor. Gerçek dünya verilerinden öğrenme ve onlara uygun yanıtlar üretme yeteneği, onu sıradan bir sohbet robotundan akıllı bir ajana dönüştürüyor.
Ajanı Eyleme Geçirmek: Araçlar ve İş Akışı
Bir YZ ajanı sadece soru yanıtlamaktan veya bilgi almaktan ötesine geçmelidir; aynı zamanda dış dünyayla etkileşim kurabilmeli, belirli görevleri yerine getirebilmelidir. Bu, LangChain4j'deki "Araçlar" (Tools) konseptiyle sağlanır. Araçlar, bir ajanın belirli bir görevi yerine getirmek için kullanabileceği fonksiyonları veya API'leri temsil eder.
Ajanın Karar Verme Mekanizması: Prompt Mühendisliği
Bir ajan, hangi aracı ne zaman kullanacağına karar vermek için bir LLM kullanır. Bu karar verme süreci, LLM'e verilen talimatların (prompt'ların) kalitesine bağlıdır. Etkili bir prompt mühendisliği, ajanın doğru aracı doğru bağlamda kullanmasını sağlar.
Ajanın çalışma prensibi genellikle şöyledir:
- Kullanıcı bir sorgu veya talimat gönderir.
- Ajan, LLM'e (iç hafızası, mevcut araçları ve kullanıcının sorgusuyla birlikte) "Bu görevi tamamlamak için hangi aracı kullanmalıyım?" diye sorar.
- LLM, en uygun aracı ve parametrelerini belirler.
- Ajan, bu aracı çağırır ve sonucunu alır.
- Ajan, aradan gelen sonucu ve orijinal sorguyu tekrar LLM'e gönderir ve bir nihai yanıt üretmesini ister.
Dış Dünyayla İletişim: Araç Tanımlama ve Kullanımı
LangChain4j, ajanlara dış fonksiyonları entegre etmek için Tool arayüzünü sunar. Bir araç, herhangi bir Java metodunu temsil edebilir. Örneğin, bir hava durumu API'sini sorgulayan, bir veritabanından veri çeken veya bir e-posta gönderen bir metod bir araç olabilir.
Örnek olarak, basit bir hesap makinesi aracı oluşturalım:
import dev.langchain4j.agent.tool.Tool;
public class Calculator {
@Tool("iki sayıyı toplar") // Araca bir açıklama ekliyoruz, LLM bunu kullanarak aracı ne zaman çağıracağını anlar
public double add(double a, double b) {
return a + b;
}
@Tool("iki sayıyı çarpar")
public double multiply(double a, double b) {
return a * b;
}
}
Şimdi bu aracı ve daha önce oluşturduğumuz LLM'i, hafızayı ve retriever'ı bir araya getirerek bir AiServices ajanı oluşturalım. AiServices declarative bir yaklaşım sunarak ajan oluşturmayı basitleştirir.
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiEmbeddingModel;
import dev.langchain4j.rag.content.retriever.ContentRetriever;
import dev.langchain4j.rag.content.retriever.EmbeddingStoreContentRetriever;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.store.embedding.mongodb.MongoDBAtlasVectorStore;
import dev.langchain4j.store.memory.chat.MongoDBChatMessageHistory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
public class AdvancedAgent {
private static final Logger logger = LoggerFactory.getLogger(AdvancedAgent.class);
private static final String MONGO_CONNECTION_STRING = "mongodb+srv://:@cluster0.abcde.mongodb.net/?retryWrites=true&w=majority";
private static final String DATABASE_NAME = "ai_agent_db";
private static final String DOCS_COLLECTION_NAME = "documents";
private static final String CHAT_HISTORY_COLLECTION_NAME = "chat_history";
private static final String VECTOR_INDEX_NAME = "vector_index";
// Ajanımızın yeteneklerini tanımlayan arayüz
interface Assistant {
String chat(String message);
}
public static void main(String[] args) {
String openaiApiKey = System.getenv("OPENAI_API_KEY");
if (openaiApiKey == null || openaiApiKey.isEmpty()) {
logger.error("Hata: OPENAI_API_KEY ortam değişkeni ayarlanmamış.");
return;
}
MongoClient mongoClient = MongoClients.create(MONGO_CONNECTION_STRING);
ChatLanguageModel chatModel = OpenAiChatModel.builder()
.apiKey(openaiApiKey)
.modelName("gpt-4o") // Daha gelişmiş ajanlar için gpt-4o veya gpt-4 kullanmak daha iyidir
.temperature(0.7)
.build();
EmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()
.apiKey(openaiApiKey)
.modelName("text-embedding-ada-002")
.build();
MongoDBAtlasVectorStore vectorStore = MongoDBAtlasVectorStore.builder()
.mongoClient(mongoClient)
.databaseName(DATABASE_NAME)
.collectionName(DOCS_COLLECTION_NAME)
.indexName(VECTOR_INDEX_NAME)
.embeddingModel(embeddingModel)
.build();
ContentRetriever contentRetriever = EmbeddingStoreContentRetriever.builder()
.embeddingStore(vectorStore)
.embeddingModel(embeddingModel)
.maxResults(3) // En alakalı 3 belgeyi getir
.build();
MongoDBChatMessageHistory mongoChatMessageHistory = new MongoDBChatMessageHistory(
mongoClient,
DATABASE_NAME,
CHAT_HISTORY_COLLECTION_NAME,
"user789" // Ajanın konuşma geçmişini bu ID ile sakla
);
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.maxMessages(10)
.chatMessageHistory(mongoChatMessageHistory)
.build();
// Ajanı oluştur
Assistant assistant = AiServices.builder(Assistant.class)
.chatLanguageModel(chatModel)
.chatMemory(chatMemory)
.contentRetriever(contentRetriever) // RAG için
.tools(new Calculator()) // Hesap makinesi aracını ekle
.build();
// Ajan ile etkileşimler
System.out.println("AI: " + assistant.chat("Merhaba, benim adım Mert. Nasılsın?"));
System.out.println("AI: " + assistant.chat("Bugün İstanbul hakkında ilginç bir bilgi verir misin?"));
System.out.println("AI: " + assistant.chat("25 ile 13'ü çarpar mısın?"));
System.out.println("AI: " + assistant.chat("Daha önce sana adımı söylemiş miydim?"));
mongoClient.close();
}
}
Bu kod bloğunda, AiServices kullanarak, bir Assistant arayüzünü uygulayan bir ajan oluşturuyoruz. Bu ajan, sohbet modelini, hafızayı, RAG için ContentRetriever'ı ve Calculator aracını kullanır. LLM, kullanıcının sorgusuna göre, ya konuşma geçmişinden veya bilgi tabanından bilgi alır, ya da Calculator aracını çağırarak bir işlem yapar. Örneğin, "25 ile 13'ü çarpar mısın?" dediğinizde, ajan otomatik olarak Calculator.multiply metodunu çağıracak ve sonucu kullanıcıya bildirecektir.
Bu yapı, ajanlarımızın çok daha dinamik ve işlevsel olmasını sağlar. Sadece yanıt vermekle kalmayıp, belirli görevleri yerine getirmek için dış servisleri ve fonksiyonları kullanabilirler. Bu, akıllı otomasyon ve etkileşimli YZ uygulamalarının temelini oluşturur.
Mobil Dostu Tasarım: AI Uygulamanızı Her Cihazda Erişilebilir Kılın
Yapay zeka ajanınızı geliştirmek harika, ancak bu ajana kullanıcıların kolayca erişebilmesi de çok önemli. Günümüzde mobil cihazlar üzerinden internete erişim, masaüstünden çok daha yaygın hale geldi. Bu nedenle, YZ uygulamanızın web arayüzünün veya mobil uygulamasının mobil dostu olması hayati önem taşır. HTML ve CSS kullanarak mobil uyumlu bir arayüz oluştururken dikkat etmeniz gereken bazı temel prensipler ve pratik örnekler sunacağım.
Neden Mobil Dostu Tasarım Önemlidir?
- Kullanıcı Deneyimi: Mobil cihazlardan erişen kullanıcılar, kötü optimize edilmiş sitelerde hızlıca hayal kırıklığına uğrar ve sitenizi terk ederler. Akıcı bir deneyim, uygulamanızın benimsenmesini artırır.
- SEO Performansı: Google gibi arama motorları, mobil uyumlu sitelere arama sonuçlarında öncelik verir. Bu, YZ uygulamanızın keşfedilebilirliği için önemlidir.
- Erişilebilirlik: Farklı ekran boyutlarına ve giriş yöntemlerine (dokunma, klavye) uyum sağlamak, daha geniş bir kullanıcı kitlesine ulaşmanızı sağlar.
Mobil Uyumlu HTML ve CSS İçin Temel Prensipler
- Duyarlı Tasarım (Responsive Design): Bu, uygulamanızın farklı ekran boyutlarına ve çözünürlüklerine otomatik olarak uyum sağlaması anlamına gelir. Temel olarak, akışkan ızgaralar, esnek resimler ve medya sorguları (media queries) kullanılır.
- Meta Viewport Etiketi: Her duyarlı web sayfası,
bölümünde bu etiketi içermelidir. Bu, tarayıcıya sayfanın cihaz genişliğine göre ölçeklenmesini söyler. - Akışkan Birimler:
pxgibi sabit birimler yerine%(yüzde),vh(viewport height),vw(viewport width),em,remgibi akışkan birimler kullanın. - Medya Sorguları (Media Queries): CSS kurallarını belirli ekran boyutlarına, yönelimlere veya diğer cihaz özelliklerine göre uygulamak için kullanılırlar.
Mobil Uyumlu HTML Üretimi ve Medya Sorgusu Örnekleri
Bu makalenin başındaki
Örnek Duyarlı Tablo
| Özellik | Açıklama | Fayda |
|---|---|---|
| MongoDB Atlas | Bulut tabanlı, ölçeklenebilir veritabanı. | Kolay yönetim, yüksek performans. |
| LangChain4j | YZ ajan geliştirme framework'ü. | Hızlı YZ uygulama geliştirme. |
Bu örnek, bir tablonun büyük ekranlarda standart bir tablo olarak görünmesini, ancak 768px veya daha küçük ekranlarda her satırın dikey olarak istiflenmiş kartlar gibi görünmesini sağlar. Her hücrenin içeriği, ::before sözde elemanı kullanılarak orijinal sütun başlığı ile etiketlenir, böylece mobil görünümde bile verinin ne anlama geldiği netleşir.
Mobil dostu tasarım sadece YZ uygulamanızın erişilebilirliğini artırmakla kalmaz, aynı zamanda kullanıcıların uygulamanızla daha etkili bir şekilde etkileşim kurmasını sağlar. Bir YZ ajanı ne kadar akıllı olursa olsun, kullanıcı arayüzü kötüyse değeri anlaşılamaz. Bu nedenle, YZ ajanınızın arka plan teknolojileri kadar, ön yüzünün de modern standartlara uygun olması önemlidir.
Vaka Analizi: Akıllı Envanter Yönetim Ajanı
Şimdiye kadar öğrendiklerimizi gerçek bir senaryoda nasıl uygulayabileceğimizi gösteren bir vaka analizine dalalım: bir Akıllı Envanter Yönetim Ajanı. Bu ajan, bir depodaki ürünleri izlemek, stok seviyelerini güncellemek, sipariş durumlarını sorgulamak ve hatta tedarik zinciri yöneticilerine proaktif önerilerde bulunmak için tasarlanmıştır.
Problem Senaryosu
Büyük bir e-ticaret şirketi, depolarındaki envanter yönetimini manuel süreçler nedeniyle etkin bir şekilde yapamıyor. Stok fazlası veya stok tükenmesi gibi durumlar sıkça yaşanıyor, bu da gelir kaybına ve müşteri memnuniyetsizliğine yol açıyor. Ayrıca, tedarik zinciri yöneticileri, karmaşık veritabanı sorguları ve raporlar aracılığıyla güncel bilgilere erişmekte zorlanıyorlar.
LangChain4j ve MongoDB Çözümü
Bu problemi çözmek için LangChain4j ve MongoDB kullanarak akıllı bir envanter yönetim ajanı geliştirilebilir. İşte ajanın mimarisi ve bileşenleri:
- MongoDB Envanter Veritabanı:
- Şirketin tüm ürün envanteri, tedarikçi bilgileri, sipariş geçmişi ve depo lokasyonları MongoDB koleksiyonlarında depolanır. Doküman tabanlı yapı, farklı ürün türleri için esnek şemalar sağlar.
- Her ürün açıklaması, anahtar özellikler ve tedarikçi notları gibi metinsel veriler, vektör gömmeleri oluşturularak
inventory_documentskoleksiyonuna MongoDB Atlas Vector Search için kaydedilir. - Geçmiş sipariş trendleri ve satış verileri de analitik için MongoDB'de tutulur.
- LangChain4j Tabanlı YZ Ajanı:
- LLM (gpt-4o): Ajanın karar verme ve doğal dil anlama yeteneğini sağlar.
- Hafıza Yönetimi (
MongoDBChatMessageHistory): Tedarik zinciri yöneticilerinin ajanla yaptığı geçmiş tüm konuşmalarıchat_sessionskoleksiyonunda kalıcı olarak saklar. Bu, ajanın bağlamı hatırlamasını ve kişiselleştirilmiş bir deneyim sunmasını sağlar. Örneğin, bir yönetici "Dün sorduğum ürünün stok durumu ne oldu?" diye sorduğunda, ajan dün hangi ürünü sorduğunu hatırlayabilir. - RAG (Retrieval-Augmented Generation) için
MongoDBAtlasVectorStore: Yöneticilerin doğal dil sorgularını (örneğin, "XYZ modelinin özelliklerini açıklar mısın?" veya "Bu ürünün benzerleri var mı?") işlemek için kullanılır. Ajan, bu sorguların vektör gömmelerini oluşturur veinventory_documentskoleksiyonunda anlamsal olarak en alakalı ürün bilgilerini çeker. Bu sayede, LLM, şirketin kendi envanter verilerine dayanarak doğru ve detaylı yanıtlar verir. - Araçlar (Tools): Ajanın dış sistemlerle etkileşime girmesini sağlar.
StockUpdateTool: Bir ürünün stok seviyesini veritabanında güncelleyebilir. (@Tool("Belirli bir ürünün stok miktarını günceller"))OrderQueryTool: Belirli bir siparişin durumunu veya belirli bir tedarikçiden gelen siparişleri sorgulayabilir. (@Tool("Siparişin durumunu veya tedarikçi bazında siparişleri sorgular"))DemandPredictionTool: Geçmiş satış verilerine dayanarak bir ürünün gelecekteki talebini tahmin eden harici bir makine öğrenimi modelini çağırabilir. (@Tool("Bir ürünün gelecekteki talebini tahmin eder"))AlertTool: Düşük stok durumunda veya kritik bir sipariş gecikmesinde sorumlu personele otomatik uyarı (e-posta/SMS) gönderebilir. (@Tool("Belirli bir personele uyarı gönderir"))
Örnek Kullanım Akışı
Bir tedarik zinciri yöneticisi, ajanla aşağıdaki gibi etkileşim kurabilir:
- Yönetici: "Merhaba ajan, geçen ay en çok satan ürünlerimiz hangileriydi?"
* Ajan: MongoDB'deki satış geçmişini sorgular (belkiOrderQueryToolbenzeri bir aracı kullanarak) ve en çok satan ürünlerin listesini döndürür. - Yönetici: "Harika! 'Akıllı Saat X' ürününün stok seviyesi düşmeye başladı mı? Geçen haftaki talebine göre ne kadar süremiz var?"
* Ajan:StockQueryToolileAkıllı Saat X'in mevcut stokunu kontrol eder. ArdındanDemandPredictionTool'u çağırarak geçmiş talep verilerine göre kalan süreyi hesaplar ve "Stok kritik seviyeye yaklaşıyor. Geçen haftaki talep eğilimiyle 3 gün içinde tükenebilir." gibi bir yanıt verir. - Yönetici: "Tamam, lütfen 'Akıllı Saat X' için 500 adet yeni sipariş oluştur ve mevcut stoğu 1000 adete çıkar. Tedarikçiyi de bilgilendir."
* Ajan:StockUpdateTool'u kullanarak MongoDB'deki stok miktarını günceller.AlertTool'u kullanarak ilgili tedarikçiye ve satın alma departmanına otomatik e-posta gönderir. Yöneticinin onayını aldıktan sonra işlemi tamamladığını bildirir. - Yönetici: "Bu ürünün teknik özelliklerini bana özetler misin?"
* Ajan: Sorguyu vektör gömmesine dönüştürür,MongoDBAtlasVectorStore'dan ilgili ürün açıklamasını RAG deseniyle çeker ve bu bilgilere dayanarak özet bir yanıt sunar.
Elde Edilen Faydalar
- Artan Verimlilik: Manuel veri sorgulama ve raporlama ihtiyacını ortadan kaldırır.
- Daha İyi Karar Verme: Güncel ve doğru bilgilere anında erişim sağlayarak daha bilinçli tedarik zinciri kararları alınmasına yardımcı olur.
- Azalan Stok Hataları: Stok fazlası veya tükenmesi riskini azaltır.
- Proaktif Yönetim: Tahmin araçları sayesinde olası sorunlar önceden belirlenir ve önlem alınır.
- Kişiselleştirilmiş Deneyim: MongoDB'de tutulan geçmiş konuşmalar sayesinde ajan, her yöneticiye özel ve bağlamsal yanıtlar sunar.
Bu vaka analizi, MongoDB ve LangChain4j'nin bir araya gelerek nasıl güçlü ve akıllı bir iş çözümü oluşturabileceğini açıkça göstermektedir. Ajanlar, iş süreçlerini otomatikleştirme ve insan karar verme yeteneklerini güçlendirme konusunda muazzam bir potansiyele sahiptir.
Sonuç: Geleceğe Yönelik Adımlar ve Sıkça Sorulan Sorular
Bu makalede, MongoDB ve LangChain4j kullanarak ilk yapay zeka ajanı uygulamanızı nasıl geliştireceğinizi adım adım öğrendik. YZ ajanlarının neden önemli olduğundan başlayarak, LangChain4j'nin LLM orkestrasyon yeteneklerini, MongoDB'nin esnek veri yönetimini ve özellikle MongoDB Atlas Vector Search'ün RAG deseniyle nasıl güçlü bir bilgi tabanı sağladığını detaylıca inceledik. Geliştirme ortamı kurulumundan LLM entegrasyonuna, kalıcı hafıza eklemekten gerçek dünya verileriyle etkileşim kurmaya ve hatta ajana dış araçlar ekleyerek onu daha işlevsel hale getirmeye kadar tüm temel adımları ele aldık.
Ayrıca, bir Akıllı Envanter Yönetim Ajanı vaka analizi ile öğrendiklerimizi gerçek bir iş senaryosuna nasıl uygulayabileceğimizi gösterdik. Mobil uyumlu tasarımın önemine de değinerek, uygulamanızın kullanıcılar tarafından her cihazda erişilebilir olmasının ne kadar kritik olduğunu vurguladık. Yapay zeka ajanları, iş süreçlerini otomatikleştirme, karar alma süreçlerini destekleme ve müşteri deneyimlerini kişiselleştirme konusunda sınırsız potansiyel sunmaktadır. Bu makaledeki bilgiler ve örnekler, kendi YZ ajanlarınızı inşa etmek için sağlam bir başlangıç noktası olacaktır.
Gelecekte, ajanların yetenekleri daha da gelişecek, çok modlu (multimodal) yetenekler (metin, görüntü, ses) kazanacak ve daha karmaşık görevleri daha otonom bir şekilde yerine getirebileceklerdir. Bu alandaki sürekli öğrenme ve deneyimleme, sizi bu heyecan verici geleceğin öncülerinden biri yapacaktır. Kendi projelerinizde bu teknolojileri deneyerek sınırları zorlamaktan çekinmeyin!
Sıkça Sorulan Sorular (SSS)
1. LangChain4j ve MongoDB kullanmak için Java bilmek şart mı?
Evet, LangChain4j Java tabanlı bir kütüphanedir, bu nedenle Java programlama diline hakim olmak gereklidir. Ancak, temel Java bilgisiyle bile bu rehberdeki örnekleri anlayabilir ve uygulayabilirsiniz.
2. MongoDB Atlas Vector Search, tüm embedding modelleriyle uyumlu mu?
MongoDB Atlas Vector Search, genel olarak herhangi bir embedding modeli tarafından üretilen vektörlerle çalışabilir. Önemli olan, vektör indeksini oluştururken doğru dimensions (boyut) değerini belirtmenizdir. Örneğin, OpenAI'ın text-embedding-ada-002 modeli 1536 boyutlu vektörler üretirken, başka bir model farklı bir boyut üretebilir.
3. Kendi özel verilerimi LangChain4j ve MongoDB ile nasıl güvence altına alabilirim?
Veri güvenliği için birden fazla katmanlı yaklaşım benimsemelisiniz:
- MongoDB Atlas Güvenliği: IP beyaz listesi, ağ izolasyonu (VPC Peering), güçlü veritabanı kullanıcı parolaları ve rol tabanlı erişim kontrolü kullanın.
- API Anahtarları: OpenAI gibi servislerin API anahtarlarını ortam değişkenleri veya güvenli anahtar yönetim sistemleri aracılığıyla yönetin, asla doğrudan kodunuza gömmeyin.
- Veri Şifreleme: Hassas verileri depolarken alan düzeyinde şifreleme veya disk şifreleme seçeneklerini değerlendirin.
- Erişim Kontrolü: Uygulamanızda kullanıcı bazlı erişim kontrolü uygulayarak, her kullanıcının sadece görmesi gereken verilere erişmesini sağlayın.
4. LangChain4j ile sadece OpenAI LLM'lerini mi kullanabilirim?
Hayır, LangChain4j çeşitli LLM sağlayıcılarını destekler. OpenAI'a ek olarak, Hugging Face modelleri, Google Gemini, Anthropic Claude gibi birçok farklı modelle entegrasyon için modülleri bulunmaktadır. langchain4j-openai bağımlılığını, kullanmak istediğiniz sağlayıcının bağımlılığı ile değiştirmeniz yeterlidir.
5. Ajanımın performansını nasıl optimize edebilirim?
Performansı optimize etmek için birkaç yol vardır:
- LLM Seçimi: Daha küçük ve daha hızlı modelleri (örneğin
gpt-3.5-turbo) gereksinimlerinize uygunsa tercih edin. - Token Yönetimi:
MessageWindowChatMemory'dekimaxMessagessayısını optimize edin. Daha az mesaj, daha az token ve daha hızlı yanıt demektir. - RAG Retriever Optimizasyonu:
maxResultsdeğerini ayarlayarak getirilen belge sayısını optimize edin. Gereksiz fazla belge getirmek LLM'e yük bindirebilir. - MongoDB Atlas İndeksleri: Vektör indeksinizin doğru yapılandırıldığından ve diğer sorgularınız için gerekli diğer indekslerin de mevcut olduğundan emin olun.
- Asenkron İşlemler: Uzun süreli LLM çağrılarını veya veri işlemlerini asenkron olarak yürüterek genel yanıt süresini iyileştirebilirsiniz.