Web uygulamalarına yapay zeka entegrasyonu: LLM ve RAG mimarisi

Yapay zeka yeteneklerini web uygulamalarınıza entegre etmek, günümüzde rekabet avantajı elde etmenin en etkili yollarından biridir. OpenAI, Anthropic Claude ve yerel LLM'ler ile çalışarak, uygulamalarınıza akıllı özellikler ekleyebilirsiniz. Bu yazıda, LLM entegrasyonundan RAG (Retrieval-Augmented Generation) mimarisine kadar her şeyi adım adım inceleyeceğiz.

LLM Entegrasyonu Temelleri

API Seçimi

Piyasada birçok LLM API seçeneği mevcuttur:

OpenAI GPT-4o: En yaygın kullanılan, geniş yetenek yelpazesi
Anthropic Claude: uzun bağlam penceresi ve güvenlik odaklı yaklaşım
Google Gemini: Multimodal yetenekler güçlü
Yerel modeller (llama, mistral): Gizlilik ve maliyet avantajı

API Entegrasyonu

Bir Next.js projesinde OpenAI entegrasyonu örneği:

```typescript // lib/openai.ts import OpenAI from 'openai'

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY, })

export async function generateResponse(prompt: string) { try { const completion = await openai.chat.completions.create({ model: 'gpt-4o', messages: [ { role: 'system', content: 'Sen yardımcı bir asistansın. Kullanıcının sorularını Türkçe yanıtla.' }, { role: 'user', content: prompt } ], temperature: 0.7, max_tokens: 2000, })

return completion.choices[0].message.content

} catch (error) { console.error('OpenAI API hatası:', error) throw new Error('Yanıt üretilirken hata oluştu') } } ```

Streaming Yanıtlar

LLM'lerin uzun yanıtları üretirken kullanıcı deneyimini iyileştirmek için streaming kullanımı önemlidir:

```typescript // API route import { OpenAIStream, StreamingTextResponse } from 'ai' import OpenAI from 'openai'

const openai = new OpenAI()

export async function POST(req: Request) { const { messages } = await req.json()

const response = await openai.chat.completions.create({ model: 'gpt-4o', messages, stream: true, })

const stream = OpenAIStream(response) return new StreamingTextResponse(stream) } ```

```typescript // Frontend kullanımı 'use client'

import { useChat } from 'ai/react'

export function ChatInterface() { const { messages, input, handleInputChange, handleSubmit } = useChat({ api: '/api/chat', })

return ( <div> {messages.map(m => ( <div key={m.id} className={m.role}> {m.content} </div> ))} <form onSubmit={handleSubmit}> <input value={input} onChange={handleInputChange} /> <button type="submit">Gönder</button> </form> </div> ) } ```

RAG (Retrieval-Augmented Generation) Mimarisi

RAG Nedir?

RAG, LLM'lerin güncel ve özel verilerle çalışmasını sağlayan bir mimaridir. Geleneksel LLM'ler belirli bir tarihe kadar olan verilerle eğitilirken, RAG sayesinde gerçek zamanlı verileri kullanabilirsiniz.

RAG Nasıl Çalışır?

Belge indeksleme: Dokümanlar parçalara ayrılır ve vektörel olarak indekslenir
Sorgu işleme: Kullanıcı sorusu vektörel dönüşüme uğratılır
Benzerlik arama: En benzer belge parçaları bulunur
Yanıt üretme: Bulunan bağlam ile LLM yanıt üretir

Vektör Veritabanı Seçimi

RAG için kullanılan popüler vektör veritabanları:

Pinecone: Yönetilen, ölçeklenebilir çözüm
Weaviate: Açık kaynak, GraphQL destekli
Chroma: Hafif ve kolay kurulum
Supabase pgvector: PostgreSQL tabanlı, mevcut altyapı ile entegrasyon
Qdrant: Yüksek performanslı, Rust tabanlı

Pratik RAG Uygulaması

```typescript // RAG pipeline örneği import { OpenAIEmbeddings } from '@langchain/openai' import { ChatOpenAI } from '@langchain/openai' import { RetrievalQAChain } from 'langchain/chains' import { HNSWLib } from '@langchain/community/vectorstores/hnswlib' import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter' import * as fs from 'fs'

async function createRAGPipeline() { // 1. Dokümanı yükle ve parçala const text = fs.readFileSync('knowledge-base.txt', 'utf-8') const textSplitter = new RecursiveCharacterTextSplitter({ chunkSize: 1000, chunkOverlap: 200, }) const docs = await textSplitter.createDocuments([text])

// 2. Vektör deposu oluştur const vectorStore = await HNSWLib.fromDocuments( docs, new OpenAIEmbeddings() )

// 3. RAG chain oluştur const model = new ChatOpenAI({ temperature: 0 }) const chain = RetrievalQAChain.fromLLM( model, vectorStore.asRetriever() )

return chain }

// Kullanım const chain = await createRAGPipeline() const answer = await chain.invoke({ query: 'Ürün iade politikası nedir?' }) console.log(answer.text) ```

Chunking Stratejileri

Doğru chunking stratejisi, RAG'ın kalitesini doğrudan etkiler:

Sabit boyut: Basit ama bağlam kaybına yol açabilir
Semantic chunking: Anlamsal sınırlara göre bölme
Recursive splitting: Paragraf ve cümle sınırlarını koruyarak bölme
Hybrid approach: Birden fazla stratejinin kombinasyonu

Güvenlik ve Gizlilik

API Anahtarı Yönetimi

```typescript // .env.local dosyası OPENAI_API_KEY=sk-... ANTHROPIC_API_KEY=sk-ant-...

// Güvenli kullanım const config = { apiKey: process.env.OPENAI_API_KEY, } ```

Veri Gizliliği

LLM API'lerini kullanırken dikkat edilmesi gerekenler:

Hassas verileri API'ye göndermeden önce anonimleştirin
Yerel modeller kullanarak verilerin sunucunuzda kalmasını sağlayın
API kullanım loglarını tutun ve düzenli denetleyin
Kullanıcıların rızasını alın

Hata Yönetimi

```typescript // Hata yönetimi ile güvenli LLM çağrısı async function safeLLMCall(prompt: string, maxRetries = 3) { for (let i = 0; i < maxRetries; i++) { try { const response = await openai.chat.completions.create({ model: 'gpt-4o', messages: [{ role: 'user', content: prompt }], }) return response.choices[0].message.content } catch (error) { if (error.status === 429) { // Rate limit - bekle ve tekrar dene await new Promise(r => setTimeout(r, 1000 * Math.pow(2, i))) continue } throw error } } throw new Error('Maksimum deneme sayısı aşıldı') } ```

Maliyet Optimizasyonu

Token Kullanımını Azaltma

Kısa ve öz prompt'lar kullanın
Gereksiz bilgileri prompt'tan çıkarın
Shorter context window kullanın
Cache mekanizması uygulayın

Hybrid Yaklaşım

Her istek için LLM kullanmak yerine, basit kurallar tabanlı sistemler ile LLM'i birlikte kullanın:

```typescript async function smartResponse(userInput: string) { // Basit sorular için LLM kullanma if (isSimpleQuery(userInput)) { return getStaticResponse(userInput) }

// Karmaşık sorular için LLM kullan return await generateResponse(userInput) } ```

Model Seçimi

Görevin karmaşıklığına göre doğru modeli seçin:

Basit sınıflandırma: GPT-3.5-Turbo (düşük maliyet)
Metin üretimi: GPT-4o veya Claude
Kod üretimi: GPT-4o veya specialized modeller
Hassas görevler: GPT-4o veya Claude (yüksek kalite)

Ölçeklenebilirlik

Asenkron İşleme

Yüksek trafik altından LLM çağrılarını asenkron olarak yönetin:

```typescript // Job kuyruğu ile LLM işlemleri import { Queue, Worker } from 'bullmq'

const llmQueue = new Queue('llm-jobs')

const worker = new Worker('llm-jobs', async job => { const result = await generateResponse(job.data.prompt) await saveResult(job.data.userId, result) }) ```

Caching Stratejisi

Benzer sorgular için yanıt cachingleme:

```typescript import Redis from 'ioredis'

const redis = new Redis()

async function cachedLLMResponse(prompt: string) { const cacheKey = llm:${hashString(prompt)} const cached = await redis.get(cacheKey)

if (cached) return JSON.parse(cached)

const response = await generateResponse(prompt) await redis.setex(cacheKey, 3600, JSON.stringify(response)) return response } ```

Sonuç

Web uygulamalarına yapay zeka entegrasyonu, doğru mimari ve güvenlik önlemleriyle gerçekleştirildiğinde büyük avantajlar sağlar. RAG mimarisi ile özel verilerinizi LLM'lerle buluşturabilir, streaming ile kullanıcı deneyimini iyileştirebilir ve akıllı caching ile maliyetleri kontrol altına alabilirsiniz. Başlangıç için küçük bir use case ile başlayın, sonuçları ölçün ve kademeli olarak ölçekleyin.

Web uygulamalarına yapay zeka entegrasyonu: LLM ve RAG mimarisi