Gemini Nano iOS + Android: Cross-platform On-Device AI

1import com.google.ai.edge.aicore.*
2 
3class SummarizationService(context: Context) {
4    private val client = GenerativeModel(
5        modelName = "gemini-nano",
6        generationConfig {
7            temperature = 0.3f
8            maxOutputTokens = 512
9        }
10    )
11 
12    suspend fun summarize(text: String): String {
13        val response = client.generateContent(
14            "Summarize this in 2 sentences:\n\n$text"
15        )
16        return response.text ?: ""
17    }
18}
19 
20// Usage
21val service = SummarizationService(context)
22val summary = service.summarize(longArticle)

1import GoogleGenerativeAI
2 
3class OnDeviceAI {
4    private let model: GenerativeModel
5 
6    init() {
7        self.model = GenerativeModel(
8            name: "gemini-nano",
9            onDevice: true,  // Cloud değil, device
10            config: GenerationConfig(
11                temperature: 0.3,
12                maxOutputTokens: 512
13            )
14        )
15    }
16 
17    func summarize(_ text: String) async throws -> String {
18        let response = try await model.generateContent(
19            "Summarize this:\n\n\(text)"
20        )
21        return response.text ?? ""
22    }
23}
24 
25// Usage
26let ai = OnDeviceAI()
27Task {
28    let summary = try await ai.summarize(longArticle)
29}

1# pubspec.yaml
2dependencies:
3  google_generative_ai: ^0.4.0
4  gemini_nano_flutter: ^1.0.0-preview

1import 'package:gemini_nano_flutter/gemini_nano_flutter.dart';
2 
3class AIService {
4  final model = GeminiNano();
5 
6  Future summarize(String text) async {
7    final response = await model.generateContent(
8      'Summarize this: $text'
9    );
10    return response.text;
11  }
12}
13 
14// Flutter widget
15class SummaryWidget extends StatefulWidget {
16  @override
17  _SummaryWidgetState createState() => _SummaryWidgetState();
18}
19 
20class _SummaryWidgetState extends State {
21  final ai = AIService();
22  String? summary;
23  bool loading = false;
24 
25  @override
26  Widget build(BuildContext context) {
27    return Column(children: [
28      TextField(controller: _textController),
29      ElevatedButton(
30        onPressed: () async {
31          setState(() => loading = true);
32          summary = await ai.summarize(_textController.text);
33          setState(() => loading = false);
34        },
35        child: Text('Summarize'),
36      ),
37      if (loading) CircularProgressIndicator(),
38      if (summary != null) Text(summary!),
39    ]);
40  }
41}

1// npm install react-native-gemini-nano
2import GeminiNano from 'react-native-gemini-nano';
3 
4const ai = new GeminiNano({
5    modelName: 'gemini-nano',
6    temperature: 0.3
7});
8 
9async function summarize(text: string): Promise {
10    const response = await ai.generateContent(
11        `Summarize this: ${text}`
12    );
13    return response.text;
14}

1import GoogleGenerativeAI
2 
3if await GenerativeModel.onDeviceAvailable() {
4    // Use Nano
5} else {
6    // Fallback to cloud Gemini Flash via API
7    let cloudModel = GenerativeModel(name: "gemini-1.5-flash", apiKey: key)
8}

1let description = try await model.generateContent(
2    image: capturedImage,
3    "Describe this image for accessibility"
4)

1// shared/ai-service.ts — Works in RN + Web
2interface AIService {
3    isAvailable(): Promise;
4    summarize(text: string): Promise;
5    classify(text: string, categories: string[]): Promise;
6}
7 
8class HybridAIService implements AIService {
9    async isAvailable(): Promise {
10        try {
11            const { available } = await GeminiNano.checkAvailability();
12            return available;
13        } catch {
14            return false;
15        }
16    }
17 
18    async summarize(text: string): Promise {
19        if (await this.isAvailable()) {
20            return GeminiNano.generateContent(`Summarize: ${text}`);
21        }
22        // Cloud fallback
23        return CloudGemini.generate({ prompt: `Summarize: ${text}`, model: 'gemini-1.5-flash' });
24    }
25 
26    async classify(text: string, categories: string[]): Promise {
27        const prompt = `Classify as [${categories.join('|')}]: ${text}`;
28        if (await this.isAvailable()) {
29            return GeminiNano.generateContent(prompt);
30        }
31        return CloudGemini.generate({ prompt, model: 'gemini-1.5-flash' });
32    }
33}
34 
35export const ai = new HybridAIService();