DEV Community: Devansh Verma

How to Integrate AI into Your Flutter App — A Complete Guide

Devansh Verma — Sun, 07 Jun 2026 11:50:32 +0000

Building AI-powered Flutter apps used to mean managing multiple APIs, handling different SDKs, and reinventing the wheel for every project. Today, there are better ways.

In this guide, we'll explore every approach to adding AI to Flutter — from simple cloud APIs to sophisticated on-device inference — and show you which to use when.

The Problem

Flutter developers want to add AI, but face fragmentation:

Different API shapes for each provider (Gemini, OpenAI, Claude)
No standard way to switch between cloud and on-device
Tool calling, memory, and safety aren't built in
Vendor lock-in if you choose one provider

The Approaches

1. Direct API Calls (Simple, Limited)

Simplest approach — call cloud APIs directly:

import 'package:google_generative_ai/google_generative_ai.dart';

final model = GenerativeModel(
  model: 'gemini-1.5-flash',
  apiKey: 'YOUR_KEY',
);

final response = await model.generateContent([
  Content.text('What is 1337 * 42?')
]);

print(response.text);

Pros: Quick, minimal code

Cons: Only one provider, no tool calling, no memory, vendor lock-in

2. Firebase ML (Google-Owned, Limited)

Use Firebase ML Kit:

final vision = FirebaseVision.instance;
final imageLabeler = vision.imageLabeler();
final labels = await imageLabeler.processImage(image);

Pros: Built into Firebase ecosystem

Cons: Limited to Google models, no LLMs, no multi-provider support

3. On-Device Models (Privacy-First)

Run Gemma locally:

import 'package:flutter_gemma/flutter_gemma.dart';

final gemma = Gemma();
await gemma.loadModel('gemma-2b');

final response = await gemma.generateText('Hello');
print(response);

Pros: Full privacy, no API calls

Cons: Slow on older devices, large model files, limited model selection

4. Unified SDK (Best of All Worlds) - (genesis_ai_sdk)

Use a multi-provider SDK:

import 'package:genesis_ai_sdk/genesis_ai_sdk.dart';

// Start with Gemini
final agent = GenesisAgent(
  provider: GeminiProvider(apiKey: 'YOUR_KEY'),
  tools: [GenesisTools.calculator],
);

final response = await agent.chat('What is 1337 * 42?');
print(response);

// Switch to Ollama with ONE line change
final agentLocal = GenesisAgent(
  provider: OllamaProvider(model: 'llama3.2'),
  tools: [GenesisTools.calculator],
);

Tool calling, memory, and safety all built in.

Comparison Table

Feature	Direct API	Firebase ML	On-Device	Unified SDK
Multiple Providers	❌	❌	⚠️	✅
Tool Calling	❌	❌	❌	✅
Persistent Memory	❌	❌	❌	✅
Safety Guards	❌	❌	❌	✅
Privacy (On-Device)	❌	❌	✅	✅
Cloud Support	✅	⚠️	❌	✅
Setup Complexity	Low	Medium	Medium	Low

Real-World Use Cases

Travel Assistant (Cloud)

final agent = GenesisAgent(
  provider: GeminiProvider(apiKey: 'key'),
  tools: [
    searchFlights(),
    bookHotel(),
    getWeather(),
  ],
);

await agent.chat('Plan a trip to Tokyo for 3 days under $2000');

Email Agent (On-Device + Cloud)

final router = SmartRouter(
  primary: OllamaProvider(model: 'mistral'),  // Local
  secondary: OpenAIProvider(apiKey: 'key'),   // Fallback
);

final agent = GenesisAgent(provider: router);

Privacy-First Chatbot (Gemma)

final agent = GenesisAgent(
  provider: GemmaProvider(
    modelId: 'gemma-2b',
    modelPath: await GenesisHubPlatformPaths.platformModelsDir(),
  ),
  memory: HiveMemoryStore(sessionId: 'user_123'),
);

Which Approach Should You Use?

Use Direct API calls if:

You need just one provider (Gemini, OpenAI)
Simple, lightweight integration

Use Firebase ML if:

You're already in the Firebase ecosystem
Only need vision/speech tasks

Use On-Device if:

Privacy is non-negotiable
Users have no internet
Can accept slower responses

Use a Unified SDK if:

You want flexibility (cloud + on-device)
Need tool calling and memory
Want to avoid vendor lock-in
Building production apps

Getting Started with genesis_ai_sdk

Multi-provider support means you can start with cloud (fast development) and switch to on-device later (privacy/cost):

dependencies:
  genesis_ai_sdk: ^0.1.1

Then pick your provider and go:

// Cloud: Gemini, OpenAI, Claude, HuggingFace
// Local: Ollama, Gemma, GGUF
// Automatic: Fallback between them

final agent = GenesisAgent(provider: YOUR_CHOICE);

Platform support: Android, iOS, macOS, Windows, Linux, Web.

Conclusion

Integrating AI into Flutter apps is no longer complicated. You have options:

Simple projects? Direct API calls.
Firebase projects? Firebase ML.
Privacy-critical? On-device models.
Everything else? Use a unified SDK.

The future of Flutter AI development isn't picking one provider — it's having the flexibility to use the right tool for the right situation.

Resources

flutter_agentic — Build AI Agents in Flutter

Devansh Verma — Fri, 29 May 2026 09:55:02 +0000

One unified API for Gemini, OpenAI, Anthropic, HuggingFace, Ollama, on-device Gemma, and GGUF models — with tool calling, memory, per-call routing, multi-step flows, and safety guardrails built in.

The Problem

Building AI agents in Flutter is fragmented. Every provider has a different API shape. There's no standard way to switch between cloud and on-device inference. Tool calling, persistent memory, and safety guardrails are always custom implementations.

The result: developers rebuild the same plumbing for every project.

What It Is

flutter_agentic is a universal Flutter SDK for building AI agents that run locally and in the cloud. One clean API. Seven providers. Zero vendor lock-in.

Supports:

Gemini (Google)
OpenAI (GPT-4o)
Anthropic (Claude)
HuggingFace (any public model, no download needed)
Ollama (local server, no API key)
On-device Gemma (fully offline)
On-device GGUF via llama.cpp (fully offline)

Switch providers by changing one line. Your agent code stays the same.

Installation

dependencies:
  flutter_agentic: ^1.0.0

Quick Start — 10 Lines of Code

import 'package:flutter_agentic/flutter_agentic.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  await GenesisAI.init(
    providers: {'gemini': GeminiProvider(apiKey: 'YOUR_KEY')},
    defaultProviderKey: 'gemini',
  );

  final agent = GenesisAgent(
    provider: GenesisAI.defaultProvider,
    systemPrompt: 'You are a helpful assistant.',
    tools: [GenesisTools.calculator, GenesisTools.dateTime],
  );

  final response = await agent.chat('What is 1337 * 42, and what day is it?');
  print(response);
}

The agent figures out which tool to call, executes it, and returns the answer. No prompt engineering needed.

The Features That Actually Matter

Real Tool Calling — Not Just Text

The ReAct loop is fully implemented. The agent reasons → calls tools → observes results → repeats until it has a complete answer. An onStep callback fires for every intermediate step — perfect for building a "thinking…" UI.

final response = await agent.chat(
  'What is the weather in Tokyo and what is 100^0.5?',
  onStep: (step) {
    switch (step) {
      case ThinkingStep(:final thought):
        print('💭 $thought');
      case ToolCallStep(:final toolName, :final arguments):
        print('🔧 $toolName($arguments)');
      case ToolResultStep(:final toolName, :final result):
        print('✅ $toolName → $result');
      case FinalResponseStep(:final text):
        print('🏁 $text');
      case ErrorStep(:final message):
        print('❌ $message');
    }
  },
);

Custom tools are five lines:

final weatherTool = GenesisTool.define(
  name: 'get_weather',
  description: 'Returns current weather for a city.',
  params: [
    ToolParam.string('city', 'City name, e.g. "Mumbai"'),
    ToolParam.stringEnum('unit', 'Temperature unit', ['celsius', 'fahrenheit']),
  ],
  execute: (args) async {
    final city = args['city'] as String;
    final unit = args['unit'] as String? ?? 'celsius';
    return (await fetchWeather(city, unit)).toJson(); // must return Map<String,dynamic>
  },
);

Any HuggingFace Model — No Download

final agent = GenesisHub.fromHFCloud(
  modelId: 'Qwen/Qwen2.5-0.5B-Instruct',
  apiToken: 'hf_xxxx', // free at huggingface.co/settings/tokens
);
final reply = await agent.chat('Explain transformers in one sentence.');

The HF Inference Router supports virtually all public HuggingFace models via multiple GPU backends (featherless, nebius, together, sambanova). No model download, no conversion, no GPU on your end. Free tier available with any HF account.

Fully Offline — On-Device Models

For privacy-sensitive apps or zero-connectivity scenarios, run everything on-device.

For Gemma (Android, iOS, macOS, Windows):

import 'package:flutter_agentic/src/providers/gemma_provider.dart';

final dir = await GenesisHub.platformModelsDir();
// Android:       /data/user/0/com.example.app/files/genesis_models
// iOS / macOS:   <NSApplicationSupport>/genesis_models
// Windows/Linux: <ApplicationSupport>/genesis_models

final provider = GemmaProvider(
  modelId: 'gemma-3-1b-it',
  modelPath: '$dir/gemma-3-1b-it.task',
);

For GGUF via llama.cpp (Android, macOS, Windows, Linux):

import 'package:flutter_agentic/src/providers/llama_cpp_provider.dart';

final provider = LlamaCppProvider(modelPath: '/path/to/model.gguf');

GenesisHub.platformModelsDir() returns the correct writable path on every platform automatically — no more hardcoded paths that break on Android.

Memory That Survives App Restarts

In-process memory (current session only):

memory: InMemoryStore()

Persistent memory backed by Hive — survives app restarts:

// main.dart — call once at startup, before any agents
void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await HiveMemoryStore.initialize(); // ← required before use
  runApp(const MyApp());
}

// Then in your widget / service:
final agent = GenesisAgent(
  provider: myProvider,
  memory: HiveMemoryStore(),      // no constructor args
  sessionId: 'user_$userId',      // sessionId lives on the agent
);

await agent.clearHistory();
final history = await agent.getHistory();

Streaming

await for (final chunk in agent.chatStream('Tell me a story.')) {
  stdout.write(chunk);
}

Token-by-token streaming for all cloud providers.

Safety Layer Built In

Block prompt injection before it reaches the model:

final clean = InputGuard.withInjectionDetection().validate(userInput);

Redact PII from model responses (emails, phones, credit cards):

final safe = OutputGuard.withPiiRedaction().process(rawOutput);

Rate limiting per user:

RateLimiter(maxRequests: 20, windowDuration: Duration(minutes: 1)).check(userId);

Concurrency cap:

final concurrency = ConcurrencyLimiter(maxConcurrent: 3);
final response = await concurrency.run(userId, () => agent.chat(message));

The GenesisHub — One Line for Everything

From HuggingFace cloud (no download):

GenesisHub.fromHFCloud(modelId: 'Qwen/Qwen2.5-0.5B-Instruct', apiToken: '...')

From a local model file (auto-detects .gguf / .litertlm / .task):

await GenesisHub.fromFile('/path/to/model.gguf')

From Ollama:

await GenesisHub.fromOllama(model: 'llama3.2')

From HuggingFace with auto-download to device:

await GenesisHub.fromHuggingFace(
  repoId: 'litert-community/Qwen3-0.6B',
  destinationDir: await GenesisHub.platformModelsDir(),
  onProgress: (received, total) =>
      print('${(received / total * 100).toStringAsFixed(1)}%'),
)

Per-Call Routing — PolicyRouter

SmartRouter picks one backend at init time. PolicyRouter re-decides on every call — cheap / private / offline-friendly tasks stay on-device, hard reasoning goes to the cloud. Your agent call sites never change:

final router = PolicyRouter(
  providers: {
    'local': GemmaProvider(modelId: 'gemma-3-1b-it', modelPath: '...'),
    'cloud': GeminiProvider(apiKey: 'YOUR_KEY'),
  },
  defaultProvider: 'cloud',
  rules: [
    RouteRules.sensitive(useProvider: 'local'),   // PII never leaves the device
    RouteRules.shortInput(useProvider: 'local'),  // small tasks stay local & free
    RouteRules.needsTools(useProvider: 'cloud'),  // tool calls need cloud reasoning
  ],
  onRoute: (decision) => print(decision), // log it, or show a 🔒 badge in your UI
);

final agent = GenesisAgent(provider: router); // call sites are unchanged
final response = await agent.chat('My salary is 95k, help me budget');
// → automatically routed to local because "salary" is a sensitive keyword

Built-in rules: sensitive(), shortInput(), longContext(), needsTools(), streaming(), custom().

Force a specific provider for one call:

await agent.chat('Summarise this in one line.', provider: localGemma);

This is the feature that makes on-device inference practical — you don't have to choose between privacy and capability; the SDK routes each call to the right backend automatically.

GenesisFlow — Multi-Step AI Pipelines

Chain agent calls, tool runs, and transforms into one named, type-safe, observable pipeline:

final tripPlanner = GenesisFlow.start<String>('trip-planner')
    .then<String>('extract-city', (input, ctx) async {
      return (await extractor.chat('Extract the city from: $input')).text;
    })
    .then<String>('fetch-weather', (city, ctx) async {
      ctx.set('city', city);
      return await weatherApi.forecast(city);
    })
    .then<String>('write-plan', (weather, ctx) async {
      final city = ctx.get<String>('city');
      return (await planner.chat('Plan a day in $city. Weather: $weather')).text;
    });

final plan = await tripPlanner.run(
  'I want to visit Tokyo tomorrow',
  onEvent: (e) => print(e), // FlowStepStarted / Completed / Failed → live UI updates
);

Failures throw FlowException(flowName, stepName, cause) — logs point straight at the failing stage.

Smart Routing and Fallback

Automatic fallback if the primary provider fails:

final router = SmartRouter(
  primary: GeminiProvider(apiKey: '...'),
  secondary: OllamaProvider(model: 'llama3.2'),
);

Privacy-first routing — anonymise sensitive fields before they leave the device:

final router = PrivacyRouter(
  cloudProvider: OpenAIProvider(apiKey: '...'),
  sensitiveKeys: ['email', 'phone', 'ssn'],
);

Smart retry with exponential backoff:

final resilient = RetryProvider(
  inner: GeminiProvider(apiKey: '...'),
  maxAttempts: 3,
  initialDelayMs: 500, // doubles each retry with ±25% jitter
);

Platform Support

Platform	Cloud (Gemini / OpenAI / Anthropic / HF)	Ollama	On-device Gemma	GGUF / llama.cpp
Android	✅	✅	✅	✅
iOS	✅	✅	✅	⚠️ xcframework needed
macOS	✅	✅	✅	✅
Windows	✅	✅	✅	✅
Web	✅	❌	❌	❌
Linux	✅	✅	❌	✅

See PLATFORM_SETUP.md for native setup instructions per platform.

What's on the Roadmap

More providers: Mistral, Groq, Cohere
Local llama.cpp server provider
Parallel graph branches (fan-out / fan-in)
More device tools: location, camera, contacts

flutter #dart #ai #llm #sdk #agents #opensource

DEV Community: Devansh Verma

How to Integrate AI into Your Flutter App — A Complete Guide

The Problem

The Approaches

1. Direct API Calls (Simple, Limited)

2. Firebase ML (Google-Owned, Limited)

3. On-Device Models (Privacy-First)

4. Unified SDK (Best of All Worlds) - (genesis_ai_sdk)

Comparison Table

Real-World Use Cases

Travel Assistant (Cloud)

Email Agent (On-Device + Cloud)

Privacy-First Chatbot (Gemma)

Which Approach Should You Use?

Getting Started with genesis_ai_sdk

Conclusion

Resources

flutter_agentic — Build AI Agents in Flutter

The Problem

What It Is

Installation

Quick Start — 10 Lines of Code

The Features That Actually Matter

Real Tool Calling — Not Just Text

Any HuggingFace Model — No Download

Fully Offline — On-Device Models

Memory That Survives App Restarts

Streaming

Safety Layer Built In

The GenesisHub — One Line for Everything

Per-Call Routing — PolicyRouter

GenesisFlow — Multi-Step AI Pipelines

Smart Routing and Fallback

Platform Support

What's on the Roadmap

Links

flutter #dart #ai #llm #sdk #agents #opensource