Firebase Genkit: AI Uygulama Framework'ü

1// Firebase Genkit — temel flow tanımı
2import { genkit, z } from 'genkit';
3import { googleAI, gemini20Flash } from '@genkit-ai/googleai';
4 
5const ai = genkit({ plugins: [googleAI()] });
6 
7const chatFlow = ai.defineFlow(
8  {
9    name: 'chat',
10    inputSchema: z.object({ message: z.string(), userId: z.string() }),
11    outputSchema: z.object({ reply: z.string(), tokensUsed: z.number() }),
12  },
13  async ({ message, userId }) => {
14    const response = await ai.generate({
15      model: gemini20Flash,
16      prompt: message,
17      config: { temperature: 0.7, maxOutputTokens: 512 },
18    });
19    return { reply: response.text, tokensUsed: response.usage?.totalTokens ?? 0 };
20  }
21);
22 
23// Flow çalıştır
24const result = await chatFlow({ message: 'SwiftUI nedir?', userId: 'user123' });

1# Node.js projesi oluştur
2npm init -y
3npm install genkit @genkit-ai/googleai
4 
5# Veya Firebase Cloud Functions ile
6npm install genkit @genkit-ai/firebase

1import { genkit, z } from 'genkit';
2import { googleAI, gemini20Flash } from '@genkit-ai/googleai';
3 
4const ai = genkit({
5  plugins: [googleAI()],
6});
7 
8// Type-safe flow tanımı
9const summarizeFlow = ai.defineFlow(
10  {
11    name: 'summarize',
12    inputSchema: z.object({
13      text: z.string().min(100),
14      language: z.enum(['tr', 'en', 'de']).default('tr'),
15      maxSentences: z.number().min(1).max(10).default(3),
16    }),
17    outputSchema: z.object({
18      summary: z.string(),
19      keyPoints: z.array(z.string()),
20      wordCount: z.number(),
21    }),
22  },
23  async (input) => {
24    const prompt = `Aşağıdaki metni ${input.language} dilinde ${input.maxSentences} cümlede özetle.
25Ayrıca anahtar noktaları listele.
26 
27Metin:
28${input.text}
29 
30JSON formatında cevap ver:
31{
32  "summary": "...",
33  "keyPoints": ["...", "..."],
34  "wordCount": <özetteki kelime sayısı>
35}`;
36 
37    const response = await ai.generate({
38      model: gemini20Flash,
39      prompt,
40      output: { format: 'json' },
41    });
42 
43    return response.output as {
44      summary: string;
45      keyPoints: string[];
46      wordCount: number;
47    };
48  }
49);
50 
51// Kullanım
52const result = await summarizeFlow({
53  text: 'Çok uzun bir makale metni...',
54  language: 'tr',
55  maxSentences: 3,
56});

1// 1. Metin analiz flow
2const analyzeFlow = ai.defineFlow(
3  {
4    name: 'analyze',
5    inputSchema: z.string(),
6    outputSchema: z.object({
7      sentiment: z.enum(['positive', 'negative', 'neutral']),
8      topics: z.array(z.string()),
9      language: z.string(),
10    }),
11  },
12  async (text) => {
13    const response = await ai.generate({
14      model: gemini20Flash,
15      prompt: `Metni analiz et: "${text}"
16JSON: { sentiment, topics, language }`,
17      output: { format: 'json' },
18    });
19    return response.output;
20  }
21);
22 
23// 2. Çeviri flow
24const translateFlow = ai.defineFlow(
25  {
26    name: 'translate',
27    inputSchema: z.object({
28      text: z.string(),
29      targetLang: z.string(),
30    }),
31    outputSchema: z.string(),
32  },
33  async (input) => {
34    const response = await ai.generate({
35      model: gemini20Flash,
36      prompt: `"${input.text}" metnini ${input.targetLang} diline çevir.`,
37    });
38    return response.text;
39  }
40);
41 
42// 3. Zincirleme: Analiz → Çeviri → Özetleme
43const fullPipelineFlow = ai.defineFlow(
44  {
45    name: 'fullPipeline',
46    inputSchema: z.string(),
47    outputSchema: z.object({
48      analysis: z.object({
49        sentiment: z.string(),
50        topics: z.array(z.string()),
51        language: z.string(),
52      }),
53      translation: z.string(),
54      summary: z.object({
55        summary: z.string(),
56        keyPoints: z.array(z.string()),
57        wordCount: z.number(),
58      }),
59    }),
60  },
61  async (text) => {
62    const analysis = await analyzeFlow(text);
63    const translation = analysis.language !== 'tr'
64      ? await translateFlow({ text, targetLang: 'tr' })
65      : text;
66    const summary = await summarizeFlow({
67      text: translation,
68      language: 'tr',
69      maxSentences: 3,
70    });
71    return { analysis, translation, summary };
72  }
73);

1import { googleAI, gemini20Flash, gemini20Pro } from '@genkit-ai/googleai';
2 
3// Basit sorular: Flash (hızlı, ucuz)
4const quickAnswer = await ai.generate({
5  model: gemini20Flash,
6  prompt: 'TypeScript nedir?',
7});
8 
9// Karmaşık analiz: Pro (güçlü, pahalı)
10const deepAnalysis = await ai.generate({
11  model: gemini20Pro,
12  prompt: 'Bu kodun mimari sorunlarını analiz et...',
13});

1---
2model: googleai/gemini-2.0-flash
3input:
4  schema:
5    productName: string
6    category: string
7    features(array): string
8    targetAudience?: string
9output:
10  format: json
11  schema:
12    title: string
13    description: string
14    highlights(array): string
15    seoKeywords(array): string
16config:
17  temperature: 0.7
18  maxOutputTokens: 1024
19---
20 
21Sen bir e-ticaret ürün açıklaması uzmanısın.
22 
23{{productName}} ürünü için {{category}} kategorisinde
24profesyonel bir ürün açıklaması yaz.
25 
26Özellikler:
27{{#each features}}
28- {{this}}
29{{/each}}
30 
31{{#if targetAudience}}
32Hedef kitle: {{targetAudience}}
33{{/if}}
34 
35JSON formatında döndür.

1// prompts/product-description.prompt dosyasından yükle
2const productPrompt = ai.prompt('product-description');
3 
4const result = await productPrompt({
5  productName: 'AirPods Pro 3',
6  category: 'Kulaklık',
7  features: ['ANC', 'Spatial Audio', 'USB-C', '30 saat pil'],
8  targetAudience: 'Müzik tutkunları ve profesyoneller',
9});
10 
11console.log(result.output);
12// { title: "...", description: "...", highlights: [...], seoKeywords: [...] }

1import { defineRetriever, retrieve } from 'genkit';
2 
3// Custom retriever tanımla
4const myRetriever = defineRetriever(
5  {
6    name: 'supabase-docs',
7    configSchema: z.object({
8      limit: z.number().default(5),
9      namespace: z.string().optional(),
10    }),
11  },
12  async (query, config) => {
13    const embedding = await ai.embed({
14      embedder: textEmbedding004,
15      content: query.text,
16    });
17 
18    const { data } = await supabase.rpc('match_documents', {
19      query_embedding: embedding,
20      match_count: config.limit,
21    });
22 
23    return {
24      documents: data.map((doc: { content: string; metadata: Record<string, unknown> }) => ({
25        content: [{ text: doc.content }],
26        metadata: doc.metadata,
27      })),
28    };
29  }
30);
31 
32// RAG flow
33const ragFlow = ai.defineFlow(
34  { name: 'rag-chat', inputSchema: z.string(), outputSchema: z.string() },
35  async (question) => {
36    const docs = await retrieve({
37      retriever: myRetriever,
38      query: question,
39      options: { limit: 5 },
40    });
41 
42    const context = docs.documents
43      .map(d => d.content.map(c => c.text).join(''))
44      .join('\n\n');
45 
46    const response = await ai.generate({
47      model: gemini20Flash,
48      prompt: `Bağlam: ${context}\n\nSoru: ${question}\n\nCevap:`,
49    });
50 
51    return response.text;
52  }
53);

1import { evaluate } from 'genkit';
2 
3// Evaluator tanımla
4const faithfulnessEvaluator = ai.defineEvaluator(
5  {
6    name: 'faithfulness',
7    displayName: 'Bağlama Sadakat',
8    definition: 'Cevabın verilen bağlamla tutarlılığını ölçer',
9  },
10  async (datapoint) => {
11    const response = await ai.generate({
12      model: gemini20Flash,
13      prompt: `Bağlam: ${datapoint.context}
14Cevap: ${datapoint.output}
15 
16Bu cevap bağlamdaki bilgilerle tutarlı mı? 0-1 arası puan ver.
17JSON: { "score": 0.0-1.0, "reasoning": "..." }`,
18      output: { format: 'json' },
19    });
20 
21    return {
22      score: response.output.score,
23      details: { reasoning: response.output.reasoning },
24    };
25  }
26);
27 
28// Batch evaluation
29const evalResults = await evaluate({
30  evaluator: faithfulnessEvaluator,
31  dataset: testCases.map(tc => ({
32    input: tc.question,
33    output: tc.generatedAnswer,
34    context: tc.retrievedContext,
35    reference: tc.expectedAnswer,
36  })),
37});
38 
39console.log(`Ortalama skor: ${evalResults.averageScore}`);

1# Genkit Dev UI'ı başlat
2npx genkit start
3 
4# http://localhost:4000 adresinde:
5# - Flow listesi ve çalıştırma
6# - Trace görüntüleme
7# - Prompt playground
8# - Evaluation dashboard

1import { enableGoogleCloudTelemetry } from '@genkit-ai/google-cloud';
2 
3// Google Cloud ile entegre monitoring
4enableGoogleCloudTelemetry({
5  projectId: 'my-project',
6  telemetryConfig: {
7    forceDevExport: false,
8    sampler: {
9      ratio: 0.1, // %10 sampling
10    },
11  },
12});

1import { onCallGenkit } from 'firebase-functions/https';
2import { genkit } from 'genkit';
3 
4// Flow'u Cloud Function olarak deploy et
5export const chatFunction = onCallGenkit(
6  {
7    authPolicy: (auth) => {
8      if (!auth) throw new Error('Kimlik doğrulama gerekli');
9    },
10  },
11  summarizeFlow
12);

1# Dockerfile
2FROM node:20-slim
3WORKDIR /app
4COPY package*.json ./
5RUN npm ci --production
6COPY . .
7EXPOSE 3400
8CMD ["npx", "genkit", "flow:serve", "summarize", "--port", "3400"]