Cloud Functions, LangChain, & Dartantic

Bringing Full-Stack Power to Flutter Developers

---

🌟 The Game Changer for Flutter Devs

Why Dart in Cloud Functions?

• Unified Language: Write frontend, backend, and AI logic entirely in Dart. No context switching to TypeScript or Python.
• Shared Models: Share your exact data models (e.g., AiResponse, IncrementResponse) directly between your Flutter app and Firebase backend.
• Enhanced Security: Keep your GEMINI_API_KEY and other sensitive logic on the server. Never ship API keys in your client app.
• Type Safety: End-to-end type safety from the database to the UI.

---

🛠️ Step 1: The Basics

Master the Official Codelab

Before diving into AI integrations, you must understand the foundation.

👉 Deploy Dart on Firebase Functions

Please complete the official Google tutorial first. It covers:

• Setting up the Dart server environment.
• Using package:firebase_functions.
• Deploying the initial HTTP endpoints.

---

🧠 The Dart AI Ecosystem

Once your Cloud Functions environment is ready, it’s time to add intelligence. We use two dominant frameworks:

1. LangChain Dart: The heavyweight, standard pipeline adapter.
2. Dartantic AI: The fast, typed, agent-first framework.

Let’s explore what they are and how we implemented them.

---

🦜🔗 What is LangChain Dart?

• The Standard: A Dart port of the popular LangChain ecosystem.
• Pipelines: Heavily focused on declarative chains (Prompt -> LLM -> Parser).
• Versatility: Supports numerous LLM providers (Google Gemini, OpenAI, Anthropic, etc.).
• Best For: Complex multi-step pipelines (RAG, extensive document querying).

---

🎯 What is Dartantic AI?

• Agent-First: Built from the ground up for autonomous agents.
• Native Types: Designed to map LLM outputs directly into strictly typed Dart classes.
• Tool Calling: Seamless integration of Dart functions that the LLM can trigger autonomously.
• Best For: Fast integrations, structured outputs, and complex tool-calling scenarios.

---

🏗️ What We Built: The Architecture

Our Serverless server.dart Example

In this project, we created a single, powerful Cloud Functions backend that:

1. Initializes Firebase & dotenv: Loads the GEMINI_API_KEY securely from .env.
2. Exposes HTTP Callable Endpoints:
   • incrementCallable: Standard database operations (Firestore).
   • dartanticCallable: AI endpoint powered by Dartantic.
   • langchainCallable: AI endpoint powered by LangChain.
3. Uses Shared Packages: Both the Flutter client and Dart server use the exact same AiResponse model for flawless communication.

---

💻 Inside: The Dartantic Endpoint

firebase.https.onRequest(name: dartanticCallable, (request) async {
              final promptText = request.url.queryParameters['prompt'];
              
              // 1. Initialize the Agent with Gemini
              final agent = Agent.forProvider(GoogleProvider(apiKey: geminiApiKey));
              
              // 2. Send the prompt
              final dartanticResult = await agent.send(promptText);
            
              // 3. Return a strongly-typed shared response
              final aiResponse = AiResponse(
                success: true,
                result: dartanticResult.output,
                framework: 'dartantic_ai',
              );
              
              return Response(200, body: jsonEncode(aiResponse.toJson()));
            });
            

---

💻 Inside: The LangChain Endpoint

firebase.https.onRequest(name: langchainCallable, (request) async {
              final promptText = request.url.queryParameters['prompt'];
              
              // 1. Initialize the LLM
              final llm = ChatGoogleGenerativeAI(
                apiKey: geminiApiKey,
                defaultOptions: const ChatGoogleGenerativeAIOptions(model: 'gemini-2.5-flash'),
              );
              
              // 2. Invoke the model
              final langchainResult = await llm.invoke(PromptValue.string(promptText));
            
              // 3. Return the exact same response shape
              final aiResponse = AiResponse(
                success: true,
                result: langchainResult.output.content,
                framework: 'langchain_dart',
              );
              
              return Response(200, body: jsonEncode(aiResponse.toJson()));
            });
            

---

🚀 The Future is Here

One Language. One Codebase. Infinite Possibilities.

By combining Flutter, Firebase Cloud Functions for Dart, and frameworks like LangChain & Dartantic, you now have the power to build production-grade, secure, and highly intelligent AI apps without ever leaving the Dart ecosystem.

---

📱 The Flutter Frontend

Connecting to our Cloud Functions is extremely simple on the client side using the standard http package or Firebase SDK.

// Fetching from Dartantic Cloud Function
            final uri = Uri.parse('https://<YOUR-REGION>-<YOUR-PROJECT>.cloudfunctions.net/dartanticCallable');
            final response = await http.get(uri.replace(queryParameters: {
              'prompt': 'Tell me a joke about Dart'
            }));
            
            // We decode using the SAME shared model!
            final aiResponse = AiResponse.fromJson(jsonDecode(response.body));
            print(aiResponse.result);
            

---

🎨 Output in Action (1/2)

Here is a glimpse of how this looks when integrated into a Flutter application.

---

🎨 Output in Action (2/2)

And here is another example of the seamless AI integration.