Firebase Genkit: AI Uygulama Framework'ü

# Firebase Genkit: AI Uygulama Framework'ü

AI uygulaması geliştirmek, model API'sini çağırmaktan çok daha fazlası. Prompt yönetimi, model değerlendirme, retrieval pipeline'ları, observability, deployment ve testing — bunların hepsini düzgün yapman gerekiyor. İşte Firebase Genkit, tam da bu karmaşıklığı yönetmek için Google tarafından geliştirilen açık kaynak bir AI framework. Node.js'te GA (General Availability), Go ve Python desteği ile production-ready AI uygulamaları oluşturmanı sağlıyor. Haydi, Genkit'in mimarisini, flow-based yaklaşımını, prompt management sistemini ve production best practice'lerini derinlemesine inceleyelim.

💡 Not: Genkit, Firebase'in bir parçası olarak sunuluyor ama bağımsız olarak da kullanılabilir. Herhangi bir Node.js/Go/Python projesiyle çalışır — Firebase zorunlu değil. Resmi kaynak: Genkit Docs, açık kaynak: GitHub, model entegrasyonları: Google AI.

İçindekiler

• Genkit Nedir?
• Flow-Based Mimari
• Model Entegrasyonları
• Prompt Management
• RAG ve Retriever Pattern
• Evaluation ve Test
• Observability ve Monitoring
• Production Deployment
• Sonuç ve Öneriler

Genkit Nedir?

Genkit, AI özellikli uygulamalar geliştirmek için tasarlanmış bir framework. LangChain veya LlamaIndex ile aynı problem alanında ama Google'ın yaklaşımı farklı: type-safe, observable ve test edilebilir. Claude Code MCP yazımızda ele aldığımız MCP protokolü ile de entegre çalışabiliyor.

Framework Karşılaştırması

Genkit Flow Tanımı — Hızlı Başlangıç

\\\`typescript

// Firebase Genkit — temel flow tanımı

import { genkit, z } from 'genkit';

import { googleAI, gemini20Flash } from '@genkit-ai/googleai';

const ai = genkit({ plugins: [googleAI()] });

const chatFlow = ai.defineFlow(

{

name: 'chat',

inputSchema: z.object({ message: z.string(), userId: z.string() }),

outputSchema: z.object({ reply: z.string(), tokensUsed: z.number() }),

},

async ({ message, userId }) => {

const response = await ai.generate({

model: gemini20Flash,

prompt: message,

config: { temperature: 0.7, maxOutputTokens: 512 },

});

return { reply: response.text, tokensUsed: response.usage?.totalTokens ?? 0 };

}

);

// Flow çalıştır

const result = await chatFlow({ message: 'SwiftUI nedir?', userId: 'user123' });

\\\`

Flow'ların type-safe olması, çalışma zamanında hata yakalamayı kolaylaştırır. \inputSchema\ ve \outputSchema\ Zod ile tanımlanır — hem validation hem de TypeScript tip çıkarımı otomatik olarak gelir.

Kurulum

\\\`bash

# Node.js projesi oluştur

npm init -y

npm install genkit @genkit-ai/googleai

# Veya Firebase Cloud Functions ile

npm install genkit @genkit-ai/firebase

\\\`

Flow-Based Mimari

Genkit'in en güçlü konsepti flow. Flow, bir AI işlem zincirinin type-safe, observable ve test edilebilir bir temsili.

İlk Flow

\\\`typescript

import { genkit, z } from 'genkit';

import { googleAI, gemini20Flash } from '@genkit-ai/googleai';

const ai = genkit({

plugins: [googleAI()],

});

// Type-safe flow tanımı

const summarizeFlow = ai.defineFlow(

{

name: 'summarize',

inputSchema: z.object({

text: z.string().min(100),

language: z.enum(['tr', 'en', 'de']).default('tr'),

maxSentences: z.number().min(1).max(10).default(3),

}),

outputSchema: z.object({

summary: z.string(),

keyPoints: z.array(z.string()),

wordCount: z.number(),

}),

},

async (input) => {

const prompt = \`Aşağıdaki metni \${input.language} dilinde \${input.maxSentences} cümlede özetle.

Ayrıca anahtar noktaları listele.

Metin:

\${input.text}

JSON formatında cevap ver:

{

"summary": "...",

"keyPoints": ["...", "..."],

"wordCount": <özetteki kelime sayısı>

}\`;

const response = await ai.generate({

model: gemini20Flash,

prompt,

output: { format: 'json' },

});

return response.output as {

summary: string;

keyPoints: string[];

wordCount: number;

};

}

);

// Kullanım

const result = await summarizeFlow({

text: 'Çok uzun bir makale metni...',

language: 'tr',

maxSentences: 3,

});

\\\`

Flow Zinciri

Birden fazla flow'u birleştirebilirsin:

\\\`typescript

// 1. Metin analiz flow

const analyzeFlow = ai.defineFlow(

{

name: 'analyze',

inputSchema: z.string(),

outputSchema: z.object({

sentiment: z.enum(['positive', 'negative', 'neutral']),

topics: z.array(z.string()),

language: z.string(),

}),

},

async (text) => {

const response = await ai.generate({

model: gemini20Flash,

prompt: \`Metni analiz et: "\${text}"

JSON: { sentiment, topics, language }\`,

output: { format: 'json' },

});

return response.output;

}

);

// 2. Çeviri flow

const translateFlow = ai.defineFlow(

{

name: 'translate',

inputSchema: z.object({

text: z.string(),

targetLang: z.string(),

}),

outputSchema: z.string(),

},

async (input) => {

const response = await ai.generate({

model: gemini20Flash,

prompt: \"\${input.text}" metnini \${input.targetLang} diline çevir.\,

});

return response.text;

}

);

// 3. Zincirleme: Analiz → Çeviri → Özetleme

const fullPipelineFlow = ai.defineFlow(

{

name: 'fullPipeline',

inputSchema: z.string(),

outputSchema: z.object({

analysis: z.object({

sentiment: z.string(),

topics: z.array(z.string()),

language: z.string(),

}),

translation: z.string(),

summary: z.object({

summary: z.string(),

keyPoints: z.array(z.string()),

wordCount: z.number(),

}),

}),

},

async (text) => {

const analysis = await analyzeFlow(text);

const translation = analysis.language !== 'tr'

? await translateFlow({ text, targetLang: 'tr' })

: text;

const summary = await summarizeFlow({

text: translation,

language: 'tr',

maxSentences: 3,

});

return { analysis, translation, summary };

}

);

\\\`

🔍 Pro Tip: Flow'ları küçük ve tek sorumlu tut. Büyük bir "her şeyi yapan" flow yerine, küçük flow'ları zincirleme. Bu hem test edilebilirliği hem de yeniden kullanımı artırır. Flutter Clean Architecture yazımızdaki repository pattern ile benzer mantık.

Model Entegrasyonları

Genkit plugin sistemi ile birçok model provider destekler:

Desteklenen Modeller

Multi-Model Strateji

\\\`typescript

import { googleAI, gemini20Flash, gemini20Pro } from '@genkit-ai/googleai';

// Basit sorular: Flash (hızlı, ucuz)

const quickAnswer = await ai.generate({

model: gemini20Flash,

prompt: 'TypeScript nedir?',

});

// Karmaşık analiz: Pro (güçlü, pahalı)

const deepAnalysis = await ai.generate({

model: gemini20Pro,

prompt: 'Bu kodun mimari sorunlarını analiz et...',

});

\\\`

Prompt Management

Genkit'in Dotprompt sistemi, prompt'ları kod dışında yönetmeni sağlar:

Dotprompt Dosyası

\\\`text

model: googleai/gemini-2.0-flash

input:

schema:

productName: string

category: string

features(array): string

targetAudience?: string

output:

format: json

schema:

title: string

description: string

highlights(array): string

seoKeywords(array): string

config:

temperature: 0.7

maxOutputTokens: 1024

Sen bir e-ticaret ürün açıklaması uzmanısın.

{{productName}} ürünü için {{category}} kategorisinde

profesyonel bir ürün açıklaması yaz.

Özellikler:

{{#each features}}

• {{this}}

{{/each}}

{{#if targetAudience}}

Hedef kitle: {{targetAudience}}

{{/if}}

JSON formatında döndür.

\\\`

Dotprompt Kullanımı

\\\`typescript

// prompts/product-description.prompt dosyasından yükle

const productPrompt = ai.prompt('product-description');

const result = await productPrompt({

productName: 'AirPods Pro 3',

category: 'Kulaklık',

features: ['ANC', 'Spatial Audio', 'USB-C', '30 saat pil'],

targetAudience: 'Müzik tutkunları ve profesyoneller',

});

console.log(result.output);

// { title: "...", description: "...", highlights: [...], seoKeywords: [...] }

\\\`

Prompt Versiyonlama

Dotprompt dosyaları git ile versiyonlanır. A/B test yapmak kolay — iki farklı prompt versiyonunu evaluation ile karşılaştır. N8N AI Agent yazımızdaki workflow otomasyonu ile prompt versiyonlarını pipeline'a bağlayabilirsin.

RAG ve Retriever Pattern

Genkit, retriever abstraction'ı ile RAG pipeline'larını kolaylaştırır:

\\\`typescript

import { defineRetriever, retrieve } from 'genkit';

// Custom retriever tanımla

const myRetriever = defineRetriever(

{

name: 'supabase-docs',

configSchema: z.object({

limit: z.number().default(5),

namespace: z.string().optional(),

}),

},

async (query, config) => {

const embedding = await ai.embed({

embedder: textEmbedding004,

content: query.text,

});

const { data } = await supabase.rpc('match_documents', {

query_embedding: embedding,

match_count: config.limit,

});

return {

documents: data.map((doc: { content: string; metadata: Record<string, unknown> }) => ({

content: [{ text: doc.content }],

metadata: doc.metadata,

})),

};

}

);

// RAG flow

const ragFlow = ai.defineFlow(

{ name: 'rag-chat', inputSchema: z.string(), outputSchema: z.string() },

async (question) => {

const docs = await retrieve({

retriever: myRetriever,

query: question,

options: { limit: 5 },

});

const context = docs.documents

.map(d => d.content.map(c => c.text).join(''))

.join('\n\n');

const response = await ai.generate({

model: gemini20Flash,

prompt: \Bağlam: \${context}\n\nSoru: \${question}\n\nCevap:\,

});

return response.text;

}

);

\\\`

Evaluation ve Test

Genkit'in yerleşik evaluation sistemi, AI çıktılarını değerlendirmeni sağlar:

\\\`typescript

import { evaluate } from 'genkit';

// Evaluator tanımla

const faithfulnessEvaluator = ai.defineEvaluator(

{

name: 'faithfulness',

displayName: 'Bağlama Sadakat',

definition: 'Cevabın verilen bağlamla tutarlılığını ölçer',

},

async (datapoint) => {

const response = await ai.generate({

model: gemini20Flash,

prompt: \`Bağlam: \${datapoint.context}

Cevap: \${datapoint.output}

Bu cevap bağlamdaki bilgilerle tutarlı mı? 0-1 arası puan ver.

JSON: { "score": 0.0-1.0, "reasoning": "..." }\`,

output: { format: 'json' },

});

return {

score: response.output.score,

details: { reasoning: response.output.reasoning },

};

}

);

// Batch evaluation

const evalResults = await evaluate({

evaluator: faithfulnessEvaluator,

dataset: testCases.map(tc => ({

input: tc.question,

output: tc.generatedAnswer,

context: tc.retrievedContext,

reference: tc.expectedAnswer,

})),

});

console.log(\Ortalama skor: \${evalResults.averageScore}\);

\\\`

🔍 Pro Tip: Her prompt değişikliğinde evaluation çalıştır. "Bu prompt daha iyi çalışıyor gibi hissettim" güvenilir değil — metriklerle doğrula. Genkit Dev UI'da evaluation sonuçlarını görselleştirebilirsin.

Observability ve Monitoring

Genkit, OpenTelemetry ile entegre tracing sunuyor. Her flow çalıştırması otomatik olarak trace edilir:

Dev UI

\\\`bash

# Genkit Dev UI'ı başlat

npx genkit start

# http://localhost:4000 adresinde:

# - Flow listesi ve çalıştırma

# - Trace görüntüleme

# - Prompt playground

# - Evaluation dashboard

\\\`

Production Tracing

\\\`typescript

import { enableGoogleCloudTelemetry } from '@genkit-ai/google-cloud';

// Google Cloud ile entegre monitoring

enableGoogleCloudTelemetry({

projectId: 'my-project',

telemetryConfig: {

forceDevExport: false,

sampler: {

ratio: 0.1, // %10 sampling

},

},

});

\\\`

Metrikler

Her flow çalıştırmasında otomatik toplanan metrikler:

• Latency: — Her adımın süresi
• Token kullanımı: — Input/output token sayısı
• Hata oranı: — Başarısız çalıştırmalar
• Model dağılımı: — Hangi model ne kadar kullanıldı
• Maliyet: — Tahmini API maliyeti

Production Deployment

Firebase Cloud Functions

\\\`typescript

import { onCallGenkit } from 'firebase-functions/https';

import { genkit } from 'genkit';

// Flow'u Cloud Function olarak deploy et

export const chatFunction = onCallGenkit(

{

authPolicy: (auth) => {

if (!auth) throw new Error('Kimlik doğrulama gerekli');

},

},

summarizeFlow

);

\\\`

Cloud Run

\\\`bash

# Dockerfile

FROM node:20-slim

WORKDIR /app

COPY package*.json ./

RUN npm ci --production

COPY . .

EXPOSE 3400

CMD ["npx", "genkit", "flow:serve", "summarize", "--port", "3400"]

\\\`

Sonuç ve Öneriler

Firebase Genkit, AI uygulama geliştirmenin karmaşıklığını önemli ölçüde azaltıyor. Flow-based mimari ile type-safe pipeline'lar, Dotprompt ile yönetilebilir prompt'lar, yerleşik evaluation ile ölçülebilir kalite ve OpenTelemetry ile production observability — bunlar production-ready AI uygulaması için gereken temel yapı taşları. Firebase Advanced yazımızdaki backend pattern'lerle birleştirdiğinde güçlü bir AI altyapısı elde edersin.

Öneriler

1. Flow'ları küçük tut — Tek sorumluluk prensibi. DeepSeek R1 gibi açık kaynak modelleri de Genkit plugin ile kullanabilirsin
2. Dotprompt kullan — Prompt'ları koddan ayır
3. Evaluation zorunlu — Her prompt değişikliğinde. Cursor AI ile hızlı iterasyon yap
4. Dev UI'ı kullan — Debugging ve prototyping için muazzam
5. Multi-model strateji — Basit = Flash, karmaşık = Pro