Flutter 教程

🎯 Genkit 定位

Genkit 是 Google 推出的全栈 AI 开发框架，Dart 版本让 Flutter 开发者能够使用相同的 API 和理念构建 AI 应用，与 Firebase Genkit 后端无缝集成。

💡 使用场景

• 智能聊天助手
• 内容生成应用
• RAG 知识库问答
• AI 工作流编排
• 多模型对比测试

统一接口支持 Gemini、Vertex AI、Ollama 等多种模型，切换模型无需修改业务代码

使用 Flow 编排复杂 AI 工作流，支持多步骤、条件分支、并行执行

定义和管理可复用的提示词模板，支持变量替换、条件渲染

内置评估工具，测试 AI 输出质量，支持自定义评估指标

检索增强生成，支持向量数据库、文档索引、语义搜索

丰富的插件支持（Pinecone、Firebase、Google Search 等）

与 Firebase 服务无缝集成（Firestore、Auth、Cloud Functions）

支持流式生成，实时显示 AI 输出，提升用户体验

# pubspec.yaml
dependencies:
  genkit: ^1.0.0
  
  # 模型提供商插件
  genkit_google_ai: ^1.0.0    # Google AI (Gemini)
  genkit_vertex_ai: ^1.0.0    # Vertex AI
  genkit_ollama: ^1.0.0       # Ollama 本地模型
  genkit_openai: ^1.0.0       # OpenAI
  
  # 向量数据库插件
  genkit_pinecone: ^1.0.0     # Pinecone 向量数据库
  genkit_chroma: ^1.0.0       # Chroma
  
  # 其他插件
  genkit_firebase: ^1.0.0     # Firebase 集成
  genkit_google_search: ^1.0.0 # Google 搜索

# .env 文件（不要提交到版本控制）
# Google AI API 密钥
GOOGLE_GENAI_API_KEY=your-google-api-key

# Vertex AI 配置
VERTEX_AI_PROJECT_ID=your-project-id
VERTEX_AI_LOCATION=us-central1

# Pinecone 配置
PINECONE_API_KEY=your-pinecone-key
PINECONE_INDEX_NAME=your-index

# OpenAI API 密钥（可选）
OPENAI_API_KEY=your-openai-key

import 'package:genkit/genkit.dart';
import 'package:genkit_google_ai/genkit_google_ai.dart';
import 'package:genkit_pinecone/genkit_pinecone.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  
  // 加载环境变量
  await DotEnv.init();
  
  // 初始化 Genkit
  final genkit = Genkit(
    plugins: [
      // Google AI 插件
      GoogleAIPlugin(
        apiKey: dotenv.env['GOOGLE_GENAI_API_KEY'],
      ),
      // Pinecone 向量数据库插件
      PineconePlugin(
        apiKey: dotenv.env['PINECONE_API_KEY'],
        indexName: dotenv.env['PINECONE_INDEX_NAME'],
      ),
    ],
    // 默认配置
    defaultModel: 'googleai/gemini-pro',
    defaultConfig: ModelConfig(
      temperature: 0.7,
      maxOutputTokens: 2000,
    ),
  );

  runApp(MyApp(genkit: genkit));
}

import 'package:genkit/genkit.dart';

class BasicGeneration {
  final Genkit genkit;

  BasicGeneration(this.genkit);

  // 简单文本生成
  Future generateText(String prompt) async {
    final response = await genkit.generate(
      model: 'googleai/gemini-pro',
      prompt: prompt,
    );
    
    return response.text;
  }

  // 带配置的生成
  Future generateWithConfig(String prompt) async {
    final response = await genkit.generate(
      model: 'googleai/gemini-pro',
      prompt: prompt,
      config: ModelConfig(
        temperature: 0.8,  // 更高创造性
        maxOutputTokens: 4000,
        topP: 0.95,
      ),
    );
    
    return response.text;
  }

  // 使用示例
  Future example() async {
    final story = await generateText('写一个关于 Flutter 开发者的科幻故事');
    print(story);
    
    final code = await generateWithConfig('用 Dart 写一个快速排序算法');
    print(code);
  }
}

import 'package:genkit/genkit.dart';

class PromptTemplates {
  final Genkit genkit;

  PromptTemplates(this.genkit);

  // 定义提示词模板
  void registerTemplates() {
    // 代码审查模板
    genkit.definePromptTemplate(
      name: 'code-review',
      template: PromptTemplate(
        messages: [
          Message(
            role: 'system',
            content: '你是一位资深的 Flutter 代码审查专家。请审查以下代码并提供改进建议。',
          ),
          Message(
            role: 'user',
            content: '''请审查以下 Dart 代码：

```dart
{{code}}
```

请从以下方面进行审查：
1. 代码规范和风格
2. 性能优化建议
3. 潜在的错误和问题
4. 最佳实践建议''',
          ),
        ],
      ),
    );

    // 应用创意生成模板
    genkit.definePromptTemplate(
      name: 'app-idea-generator',
      template: PromptTemplate(
        messages: [
          Message(
            role: 'system',
            content: '你是一位富有创意的移动应用产品经理。',
          ),
          Message(
            role: 'user',
            content: '''请为{{topic}}主题设计一个 Flutter 应用创意。

要求：
1. 应用名称（3 个选项）
2. 目标用户群体
3. 核心功能（5-7 个）
4. 盈利模式
5. 技术难点和解决方案''',
          ),
        ],
      ),
    );
  }

  // 使用模板
  Future reviewCode(String code) async {
    final response = await genkit.generateWithTemplate(
      templateName: 'code-review',
      variables: {'code': code},
    );
    
    return response.text;
  }

  // 使用示例
  Future example() async {
    final review = await reviewCode('''
class CounterWidget extends StatefulWidget {
  @override
  _CounterWidgetState createState() => _CounterWidgetState();
}

class _CounterWidgetState extends State {
  int count = 0;
  void increment() {
    count++;
  }
  @override
  Widget build(BuildContext context) {
    return Text('$count');
  }
}
''');
    print(review);
  }
}

import 'package:genkit/genkit.dart';

class AIFlowExample {
  final Genkit genkit;

  AIFlowExample(this.genkit);

  // 定义 AI 工作流
  void defineFlows() {
    // 内容生成工作流
    genkit.defineFlow(
      name: 'content-generation-flow',
      handler: (ContentInput input) async {
        // 步骤 1：生成大纲
        final outline = await genkit.generate(
          model: 'googleai/gemini-pro',
          prompt: '为"${input.topic}"生成一个详细的大纲',
        );

        // 步骤 2：根据大纲生成内容
        final content = await genkit.generate(
          model: 'googleai/gemini-pro',
          prompt: '''根据以下大纲撰写完整内容：

${outline.text}

要求：
- 详细阐述每个要点
- 提供实际示例
- 字数：${input.wordCount}字''',
        );

        // 步骤 3：质量评估
        final evaluation = await genkit.evaluate(
          model: 'googleai/gemini-pro',
          input: content.text,
          criteria: [
            EvaluationCriteria(
              name: '准确性',
              description: '内容是否准确无误',
            ),
            EvaluationCriteria(
              name: '完整性',
              description: '是否覆盖了大纲的所有要点',
            ),
            EvaluationCriteria(
              name: '可读性',
              description: '文章是否流畅易读',
            ),
          ],
        );

        // 步骤 4：如果评分低则重新生成
        if (evaluation.score < 0.8) {
          final improvedContent = await genkit.generate(
            model: 'googleai/gemini-pro',
            prompt: '''根据以下反馈改进内容：

原始内容：
${content.text}

反馈意见：
${evaluation.feedback}

请改进内容以提高评分。''',
          );
          return improvedContent.text;
        }

        return content.text;
      },
    );

    // 多步骤客服工作流
    genkit.defineFlow(
      name: 'customer-support-flow',
      handler: (SupportInput input) async {
        // 步骤 1：理解用户问题
        final understanding = await genkit.generate(
          model: 'googleai/gemini-pro',
          prompt: '分析用户问题：${input.question}',
        );

        // 步骤 2：检索知识库
        final knowledge = await retrieveKnowledge(understanding.text);

        // 步骤 3：生成回答
        final answer = await genkit.generate(
          model: 'googleai/gemini-pro',
          prompt: '''基于以下知识回答用户问题：

相关知识：
$knowledge

用户问题：
${input.question}''',
        );

        // 步骤 4：情感分析
        final sentiment = await analyzeSentiment(input.question);

        return SupportResponse(
          answer: answer.text,
          sentiment: sentiment,
          sources: knowledge.sources,
        );
      },
    );
  }

  // 执行工作流
  Future generateContent(String topic, int wordCount) async {
    final flow = genkit.getFlow('content-generation-flow');
    final result = await flow.run(ContentInput(
      topic: topic,
      wordCount: wordCount,
    ));
    return result;
  }
}

class ContentInput {
  final String topic;
  final int wordCount;
  ContentInput({required this.topic, required this.wordCount});
}

class SupportInput {
  final String question;
  SupportInput({required this.question});
}

class SupportResponse {
  final String answer;
  final String sentiment;
  final List sources;
  SupportResponse({
    required this.answer,
    required this.sentiment,
    required this.sources,
  });
}

import 'package:genkit/genkit.dart';
import 'package:genkit_pinecone/genkit_pinecone.dart';

class RAGExample {
  final Genkit genkit;
  late final VectorStore _vectorStore;

  RAGExample(this.genkit) {
    _vectorStore = genkit.getVectorStore('pinecone');
  }

  // 索引文档
  Future indexDocuments() async {
    final documents = [
      Document(
        content: 'Flutter 是 Google 开发的开源 UI 软件工具包',
        metadata: {
          'category': '技术',
          'tags': ['flutter', 'mobile', 'dart'],
          'source': 'Flutter 官方文档',
        },
      ),
      Document(
        content: 'Dart 是 Flutter 使用的编程语言，由 Google 开发',
        metadata: {
          'category': '技术',
          'tags': ['dart', 'programming', 'language'],
          'source': 'Dart 官方文档',
        },
      ),
      // ... 更多文档
    ];

    await _vectorStore.indexDocuments(
      documents: documents,
      embeddingModel: 'googleai/text-embedding-004',
    );
  }

  // RAG 查询
  Future query(String question) async {
    // 步骤 1：检索相关文档
    final relevantDocs = await _vectorStore.similaritySearch(
      query: question,
      topK: 5,
      filter: {'category': '技术'},
    );

    // 步骤 2：构建上下文
    final context = relevantDocs
        .map((doc) => '''来源：${doc.metadata['source']}
内容：${doc.content}''')
        .join('\n\n');

    // 步骤 3：生成回答
    final response = await genkit.generate(
      model: 'googleai/gemini-pro',
      prompt: '''基于以下上下文回答问题。如果上下文中没有相关信息，请说明你不知道。

上下文：
$context

问题：$question

请用中文回答。''',
    );

    return RAGResponse(
      answer: response.text,
      sources: relevantDocs.map((d) => d.metadata['source'] as String).toList(),
      confidence: response.confidence,
    );
  }

  // 使用示例
  Future example() async {
    // 先索引文档
    await indexDocuments();

    // 查询
    final response = await query('Flutter 使用什么编程语言？');
    
    print('回答：${response.answer}');
    print('来源：${response.sources}');
    print('置信度：${response.confidence}');
  }
}

class RAGResponse {
  final String answer;
  final List sources;
  final double confidence;

  RAGResponse({
    required this.answer,
    required this.sources,
    required this.confidence,
  });
}

import 'package:flutter/material.dart';
import 'package:genkit/genkit.dart';

class StreamingExample extends StatefulWidget {
  final Genkit genkit;

  const StreamingExample({Key? key, required this.genkit}) : super(key: key);

  @override
  State createState() => _StreamingExampleState();
}

class _StreamingExampleState extends State {
  final _controller = TextEditingController();
  final _output = StringBuffer();
  bool _isGenerating = false;

  Future _generateStream() async {
    if (_controller.text.isEmpty || _isGenerating) return;

    setState(() {
      _output.clear();
      _isGenerating = true;
    });

    // 流式生成
    final stream = widget.genkit.generateStream(
      model: 'googleai/gemini-pro',
      prompt: _controller.text,
    );

    // 逐块接收
    await for (final chunk in stream) {
      setState(() {
        _output.write(chunk);
      });
    }

    setState(() {
      _isGenerating = false;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: EdgeInsets.all(16),
      child: Column(
        children: [
          TextField(
            controller: _controller,
            decoration: InputDecoration(
              labelText: '输入提示词',
              border: OutlineInputBorder(),
            ),
            onSubmitted: (_) => _generateStream(),
          ),
          SizedBox(height: 16),
          ElevatedButton(
            onPressed: _isGenerating ? null : _generateStream,
            child: Text(_isGenerating ? '生成中...' : '开始生成'),
          ),
          SizedBox(height: 16),
          if (_isGenerating) LinearProgressIndicator(),
          SizedBox(height: 16),
          Expanded(
            child: Container(
              padding: EdgeInsets.all(12),
              decoration: BoxDecoration(
                border: Border.all(color: Colors.grey),
                borderRadius: BorderRadius.circular(8),
              ),
              child: SingleChildScrollView(
                child: Text(_output.toString()),
              ),
            ),
          ),
        ],
      ),
    );
  }

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }
}