DEV Community: Victor Ihedioha

Introducing the PII Mask Maven Dependency: Secure Your JSON Data with Ease

Victor Ihedioha — Tue, 12 Nov 2024 09:19:25 +0000

With privacy and data protection becoming increasingly important, I'm excited to announce the release of the new PII Masking Maven Dependency. This dependency is designed to make it effortless for developers to add personal data masking to their applications, ensuring that sensitive information stays protected.

The goal is to create an accessible, flexible, and powerful library that provides easy-to-use annotations for automatic data masking. I'm inviting the developer community to try it out, provide feedback, and join me in making this tool even better!

🎯 Why Use the PII Masking Library?

Data masking is critical in today’s digital landscape for several reasons:

Enhanced Security: Protect users’ sensitive data from exposure in logs, exceptions, or debugging output.
Regulatory Compliance: Easily adhere to regulations like GDPR, HIPAA, and PCI-DSS.
Developer-Friendly: Automatically mask data without manual intervention or additional configuration—perfect for fast-paced development environments.

This PII Mask Maven Dependency offers a powerful and straightforward approach to masking sensitive fields in your data models using simple annotations.

📦 Key Features

The library supports a variety of customization options to meet different data protection needs:

Flexible Masking Options: Choose masking patterns that best suit your data requirements.
Annotation-Based Configuration: Mark fields with a single @MaskData annotation to enable masking—no additional setup required.
Integration with Jackson: Works seamlessly with Jackson for automatic JSON serialization, ensuring that masked data is correctly represented in logs and outputs.

🤝 How It Works

The PII Masking Library offers simple annotations that can be applied directly to fields, allowing you to define:

Mask Type: Choose to mask the beginning, end, middle, or both ends of a string field.
Mask Length: Specify the number of characters to mask for more granular control.

Example Usage

Here’s how a model class can use the @MaskData annotation:

public class User {
    @MaskData(type = MaskType.MASK_END, length = 4)
    private String creditCardNumber;

    private String name;
    // getters and setters
}

🚀 Join me in Building a Secure Data Ecosystem

I believe that data security should be easy to implement, accessible, and highly customizable. This PII Masking Library is an open-source project, and we’re looking for developers to:

Try It Out: Integrate it into your applications and explore its capabilities.
Give Feedback: Let us know what works and what doesn’t, and suggest improvements.
Collaborate: Contribute to the project on GitHub, whether by submitting bug reports, suggesting features, or contributing code.

Get Started by adding this dependency to your Maven project and try out the powerful data masking capabilities today. If you’d like to collaborate or have questions, check out our GitHub repository and join the conversation.

Harmonizing Technology and Faith: The Final Composition of the AI Bible Chat App

Victor Ihedioha — Thu, 27 Jun 2024 09:45:00 +0000

Introduction

In this final part of our series, we’ll see how the local database service, the Gemini AI service, and the user interface combine to create a seamless and interactive AI Bible chat app.

At the time of creating this final write-up, I had made version 2 of the app, which includes an AI-created audio podcast.

The Symphony of Services

Our app is akin to an orchestra, where each service plays a crucial role in the overall performance. The local database service (sqflite) acts as the foundation, storing user data and scripture content for offline access. The Gemini AI service is the soloist, interpreting user queries and delivering insightful responses. The Gemini AI goes further to create delightful audio podcast content which is then transmitted through text-to-speech (TTS)

Local Database Service

The sqflite service ensures that users have a smooth experience by providing quick access to saved scriptures and chats. It’s designed to be efficient and reliable, syncing with the cloud when online to update content and user data.

The chat history is stored locally and can be retrieved at any time, allowing users to review past conversations and reflect on their learning journey.

Gemini AI Service

Integrating the Gemini AI SDK allows the app to understand and respond to complex queries. It uses natural language processing to provide users with relevant scripture passages and interpretations, making the study of the Bible more engaging.

Continuous Chat

To maintain a continuous chat experience, we keep the instance of the chat session alive throughout the app’s lifecycle. This allows users to pick up the conversation where they left off, ensuring continuity and context.

User Interface Decisions

The user interface (UI) is the conductor, guiding the user through their experience with clarity and purpose. I made several UI decisions with the user’s needs in mind:

Simplicity: The UI is clean and uncluttered, avoiding unnecessary distractions and focusing on the content.
Intuitive Navigation: The navigation is intuitive, with clear labels and logical flow, making it easy for users to find what they’re looking for.
Responsive Design: The app is responsive, providing a consistent experience across different devices and screen sizes.

Conclusion

The AI Bible Chat app is not just a tool; it's a companion for those seeking wisdom and guidance through the scriptures. By combining the local database service, the Gemini AI service, and a thoughtfully designed UI, I have created an app that not only meets technical standards but also touches the hearts of its users.

As we conclude this series, remember that the journey of innovation is ongoing. There’s always room for improvement, and feedback from users is invaluable. Let’s continue to explore, learn, and grow together in our quest to harmonize technology and faith.

Here's a link to the previous article titled: Integrating AI with Grace: The Gemini SDK and Flutter - Part 3

Download the APK app sample (arm64) here

Integrating AI with Grace: The Gemini SDK and Flutter - Part 3

Victor Ihedioha — Wed, 22 May 2024 21:08:18 +0000

Welcome to the third part of our series on building an AI Bible chat app. In this segment, we’ll explore the integration of the Google Gemini AI SDK with Flutter, delve into prompt design, and discuss maintaining persistent chat sessions.

What Is Prompt Design and Why Gemini?

Prompt design is creating and tweaking prompts given to a Large Language Model (Gemini AI Models) to get the desired type and output quality. This is a process of trial and error until you get a specific prompt that fits your use case.

Interestingly, the prompt design for the AI Bible Chat App took more than half my day, before I could get the exact output I wanted.

Training on Google AI Studio

I had to learn and experiment with Google AI Studio, a browser-based IDE for prototyping with Google's generative models.

With Generative AI, there's I had no need for a large database of Scriptures, even more, the app is capable of delivering in-depth analysis of scriptures just by using the free access Gemini API, model 1.5 pro.

The Google Gemini 1.5 pro model is multi-modal and takes texts and images as input and outputs text and input also, which is dependent on your prompt.

You could experiment with Freeform (open-ended text)
Structured (predefined format, examples of request and response), and
Chat (enables a user to have a natural ongoing conversation with the model) type of prompt, depending on your use case.

For our AI Bible Chat App, both the structured and chat types were applied for optimal output.

Integrating Google Gemini AI SDK in Flutter

The Google Gemini AI SDK is a powerful tool that allows Flutter developers to incorporate AI functionalities into their apps. Here’s how you can integrate it into your Flutter project:

Setting Up Your API Key

Before you can start using the Gemini AI SDK, you need to obtain an API key from Google AI Studio. This key will authenticate your requests to the AI services.

Installing the SDK

Add the Gemini AI SDK to your pubspec.yaml file:

dependencies:
  google_generative_ai: ^0.4.0 (or latest version)

Run flutter pub get to install the package.

Initializing the SDK

  GenerativeModel _initializeAIModel() {
    const apiKey = 'YOUR_API_KEY';
    openModel ??= GenerativeModel(
        model: 'gemini-pro',
        apiKey: apiKey,
        generationConfig: GenerationConfig(maxOutputTokens: 1000));
    return openModel!;
  }

Maintaining Persistent Chat Sessions

To keep chat sessions open for continuous interaction, you can use static variables to maintain the state across different user inputs.

  static ChatSession? openChatSession;

  ChatSession _initializeAIChatSession(
      String userQuery, String companionResponse) {
    final newChatSession = _initializeAIModel().startChat(history: [
      Content.text(userQuery),
      Content.model([TextPart(companionResponse)])
    ]);
    openChatSession = newChatSession;
    return newChatSession;
  }

Conclusion

Integrating AI into your Flutter app with the Gemini AI SDK opens up a world of possibilities. By understanding prompt design and maintaining persistent chat sessions, you can create an engaging and interactive Bible study experience for your users.

Stay tuned for the next article, Harmonizing Technology and Faith: The Final Composition of the AI Bible Chat App, where we’ll dive into the user interface design and user experience considerations for our AI Bible chat app.

Remember, the key to a successful Generative AI integration is a combination of technical know-how and creative prompt design. Keep experimenting and refining your approach to achieve the best results.

Here's a link to the previous article here

Download the APK app sample (arm64) here

Flutter & Faith: Crafting an AI Bible Chat App with Stacked Architecture - Part 2

Victor Ihedioha — Mon, 20 May 2024 08:51:41 +0000

Setting Up Flutter with Stacked for Optimal Performance

Welcome back to the second installment of our technical deep dive into building an AI Bible chat app. In the first part, we introduced the concept and the technologies involved. Now, let’s roll up our sleeves and get into the nitty-gritty of setting up Flutter with the Stacked architecture.

Why Stacked

Stacked provides a clean architecture that separates UI and business logic, which is crucial for maintainability and scalability. It’s especially beneficial for complex state management and dependency injection, ensuring that our app remains performant and responsive. To me, one special use of Stacked is the elimination of boilerplate code and unnecessary repetitive logic.

Initializing the Project

First, we set up our Flutter environment to use Stacked CLI

Install Stacked CLI

dart pub global activate stacked_cli

You might see an instruction asking you to add a pub path to your system or user path environment of your PC or Mac, please do so.

Ensure you have the latest version of Flutter installed and your favorite IDE ready to go.

Create a new Flutter project leveraging Stacked CLI

stacked create app companion --description MyApp --org com.myapp

The above line tells Stacked CLI to create a new Flutter project called "companion", with description, "MyApp", and company domain, which is a unique identifier of your app, in case you decide to publish on the app stores "com.myapp"

Sit, watch, and marvel at how Stacked CLI creates your Flutter app with necessary starter dependencies, starter views, view-models, and test classes. What more can a productive mobile engineer ask for?

You can add new views, services, dialogs, bottomsheets, widgets, and all come with their view-model and test classes.

stacked create view bible_chat
stacked create service bible_chat
stacked create dialog history_dialog

Once you make changes to your models, modify any view, let's say your view now accepts a parameter, instead of executing the command:

flutter pub run build_runner build --delete-conflicting-outputs

You can run stacked generate.

stacked generate

Preparing the Bible Data

Our app’s core functionality revolves around providing users with scripture passages. To do this, we need a comprehensive dataset that includes the books of the Bible, chapters, verses, and various translations in different languages. "I have reasons I didn't engage the Gemini AI for this task"

The bible data will be initialised and used on the start of the project in a very fast way.

Here's a sample JSON of our Bible data placed in assets/data/app_bible.json in our project

  {
    "versions": [
        {
            "name": "King James Vversion",
            "label": "KJV"
        },
        {
            "name": "New King James Vversion",
            "label": "NKJV"
        }
   ],
   "languages": [
        "English",
        "Spanish",
        "French",
        "Italian",
        "Portuguese",
        "Pidgin",
        "Igbo",
        "Yoruba",
        "Hausa"
  ],
 "books": [
    {
      "name": "Genesis",
      "chapters": [
        {
          "number": 1,
          "verses": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]
        },
        {
          "number": 2,
          "verses": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
        }
      ]
    },
{
      "name": "Exodus",
      "chapters": [
        {
          "number": 1,
          "verses": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]
        },
        {
          "number": 2,
          "verses": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
        }
      ]
    }
  ]
}

Here's what our Bible data service looks like

class BibleDataService {

  Map<String, dynamic> _bibleData = {};

  Future<Map<String, dynamic>?> readJson() async {
    try {
      final String response =
          await rootBundle.loadString('assets/data/app_bible.json');
      _bibleData = await jsonDecode(response);
      return _bibleData;
    } catch (e) {
      return null;
    }
  }

  List<String> getBooks() {
    return _bibleData['books']
        .map((book) => book['name'])
        .whereType<String>()
        .toList();
  }

  List<int> getChapters(String bookName) {
    final book =
        _bibleData['books'].firstWhere((book) => book['name'] == bookName);
    return book['chapters']
        .map((chapter) => chapter['number'])
        .whereType<int>()
        .toList();
  }

  List<int> getVerses(String bookName, int chapterNumber) {
    final book =
        _bibleData['books'].firstWhere((book) => book['name'] == bookName);
    final chapter = book['chapters']
        .firstWhere((chapter) => chapter['number'] == chapterNumber);
    return chapter['verses'].cast<int>();
  }

  List<String> getVersions() {
    return _bibleData['versions']
        .map((version) => version['label'])
        .whereType<String>()
        .toList();
  }

  List<String> getLanguages() {
    return _bibleData['languages']
        .map((language) => language)
        .whereType<String>()
        .toList();
  }
}

Note: You could create models that mock this same exact data, making it even more easier.

Chat Models for a seamless chat experience

We need models to represent conversations and sessions in our app, so the user can have continuous conversations with Gemini AI and access the history of conversations with Gemini AI in our app.

conversation.dart

class Conversation {
  int? id;
  String? conversationId;
  String? role;
  String? message;
  DateTime? timestamp;

  Conversation({
    this.id,
    this.conversationId,
    this.role,
    this.message,
    this.timestamp,
  });

  Conversation.fromJson(Map<String, dynamic> json) {
    id = json['id'];
    conversationId = json['conversationId'];
    role = json['role'];
    message = json['message'];
    timestamp = DateTime.parse(json['timestamp']);
  }

  Map<String, dynamic> toJson() {
    final Map<String, dynamic> data = <String, dynamic>{};
    data['id'] = id;
    data['conversationId'] = conversationId;
    data['role'] = role;
    data['message'] = message;
    data['timestamp'] = timestamp?.toIso8601String();
    return data;
  }

  factory Conversation.fromMap(Map<String, dynamic> map) {
    return Conversation(
      id: map['id'],
      conversationId: map['conversationId'],
      role: map['role'],
      message: map['message'],
      timestamp: DateTime.parse(map['timestamp']),
    );
  }

  Map<String, dynamic> toMap() {
    return {
      'id': id,
      'conversationId': conversationId,
      'role': role,
      'message': message,
      'timestamp': timestamp?.toIso8601String(),
    };
  }
}

session.dart

class Session {
  String? sessionId;
  String? conversationId;
  String? title;
  DateTime? timestamp;

  Session({
    this.sessionId,
    this.conversationId,
    this.title,
    this.timestamp,
  });

  Session.fromJson(Map<String, dynamic> json) {
    sessionId = json['sessionId'];
    conversationId = json['conversationId'];
    title = json['title'];
    timestamp = DateTime.parse(json['timestamp']);
  }

  Map<String, dynamic> toJson() {
    final Map<String, dynamic> data = <String, dynamic>{};
    data['sessionId'] = sessionId;
    data['conversationId'] = conversationId;
    data['title'] = title;
    data['timestamp'] = timestamp?.toIso8601String();
    return data;
  }

  factory Session.fromMap(Map<String, dynamic> map) {
    return Session(
      sessionId: map['sessionId'],
      conversationId: map['conversationId'],
      title: map['title'],
      timestamp: DateTime.parse(map['timestamp']),
    );
  }

  Map<String, dynamic> toMap() {
    return {
      'sessionId': sessionId,
      'conversationId': conversationId,
      'title': title,
      'timestamp': timestamp?.toIso8601String(),
    };
  }
}

session_conversations.dart (To identify group of conversations with the associated session)

class SessionConversations {
  Session? session;
  List<Conversation>? conversations;

  SessionConversations({
    this.session,
    this.conversations,
  });

  SessionConversations.fromJson(Map<String, dynamic> json) {
    session = json['session'];
    if (json['conversations'] != null) {
      conversations = <Conversation>[];
      json['conversations'].forEach((v) {
        conversations!.add(Conversation.fromJson(v));
      });
    }
  }

  Map<String, dynamic> toJson() {
    final Map<String, dynamic> data = <String, dynamic>{};
    data['session'] = session;
    if (conversations != null) {
      data['conversations'] =
          conversations!.map((conversation) => conversation.toJson()).toList();
    }
    return data;
  }

  factory SessionConversations.fromMap(Map<String, dynamic> map) {
    return SessionConversations(
      session: map['session'],
      conversations: List<Conversation>.from(map['conversations']
          ?.map((conversation) => Conversation.fromMap(conversation))),
    );
  }

  Map<String, dynamic> toMap() {
    return {
      'session': session,
      'conversations':
          conversations?.map((conversation) => conversation.toMap()).toList(),
    };
  }
}

sessions.dart (History of all conversations by the user)

class Sessions {
  List<SessionConversations>? sessions;

  Sessions({
    this.sessions,
  });

  Sessions.fromJson(Map<String, dynamic> json) {
    if (json['sessions'] != null) {
      sessions = <SessionConversations>[];
      json['conversations'].forEach((v) {
        sessions!.add(SessionConversations.fromJson(v));
      });
    }
  }

  Map<String, dynamic> toJson() {
    final Map<String, dynamic> data = <String, dynamic>{};
    if (sessions != null) {
      data['sessions'] =
          sessions!.map((sessions) => sessions.toJson()).toList();
    }
    return data;
  }

  factory Sessions.fromMap(Map<String, dynamic> map) {
    return Sessions(
      sessions: List<SessionConversations>.from(map['sessions']
          ?.map((sessions) => SessionConversations.fromMap(sessions))),
    );
  }

  Map<String, dynamic> toMap() {
    return {
      'sessions': sessions?.map((sessions) => sessions.toMap()).toList(),
    };
  }
}

Local Storage with sqflite

With our models in place, we can now set up sqflite for local storage. This will allow users to access history of conversations even when offline, and also pickup from where they left off.

1_bible_chat.sql (assets/sql/1_bible_chat.sql)

CREATE TABLE session (
    sessionId TEXT PRIMARY KEY,
    conversationId TEXT UNIQUE,
    title TEXT,
    timestamp DATETIME
);

CREATE TABLE conversation (
    id INTEGER PRIMARY KEY,
    conversationId TEXT,
    role VARCHAR(50),
    message TEXT,
    timestamp DATETIME,
    FOREIGN KEY (conversationId) REFERENCES session(conversationId)
);

A glance at our database service class. You are to have other classes that will involve fetching and inserting data into the database

class DatabaseService {
  final _logger = getLogger('DatabaseService');
  final _databaseMigrationService = locator<DatabaseMigrationService>();

  late final Database _database;
  final String _sessionTable = 'session';
  final String _conversationTable = 'conversation';

  Future<void> init() async {
    _logger.i('Initializing database');
    final directory = await getApplicationDocumentsDirectory();
    _database = await openDatabase(
      '${directory.path}/bible_chat',
      version: 1,
    );
    try {
      _logger.i('Creating database tables');
      // Apply migration on every start
      await _databaseMigrationService.runMigration(
        _database,
        migrationFiles: [
          '1_bible_chat.sql',
        ],
        verbose: true,
      );
      _logger.i('Database tables created');
    } catch (e, s) {
      _logger.v('Error creating database tables', e, s);
    }
  }

  Future<void> createConversation(Conversation conversation) async {
    _logger.i('storing conversation data');
    try {
      await _database.insert(
        _conversationTable,
        conversation.toMap(),
        conflictAlgorithm: ConflictAlgorithm.ignore,
      );
      _logger.i('Conversation data stored');
    } catch (e) {
      _logger.e('error trying to store a conversation data');
    }
  }

  Future<void> createSession(Session session) async {
    _logger.i('storing session data');
    try {
      await _database.insert(
        _sessionTable,
        session.toMap(),
        conflictAlgorithm: ConflictAlgorithm.ignore,
      );
      _logger.i('Session data stored');
    } catch (e) {
      _logger.e('error trying to store a session data');
    }
  }
}

Conclusion

In this article, we’ve set up our Flutter project with the Stacked architecture and prepared our Bible data for use within the app. We’ve also implemented local storage using sqflite, ensuring users enjoy a seamless offline experience.

Stay tuned for the next part, where we’ll dive into integrating the Gemini AI SDK to bring our chat app to life with intelligent scripture search capabilities.

Remember, the journey of learning and development is continuous. As we build and improve our app, we’re also refining our skills and pushing the boundaries of what’s possible with technology.

Here's a link to the previous article https://dev.to/apow/building-an-ai-powered-bible-chat-app-a-technical-journey-with-gemini-ai-sdk-and-flutter-3mil

I will be updating this article with a link to the next article titled: Integrating AI with Grace: The Gemini SDK and Flutter - Part 3

Download the APK app sample (arm64) here

Building an AI-Powered Bible Chat App: A Technical Journey with Gemini AI SDK and Flutter

Victor Ihedioha — Sat, 18 May 2024 11:33:28 +0000

Introduction

With the integration of artificial intelligence (AI) becoming a game-changer in today's world, I recently embarked on creating a mobile application – an AI-powered Bible chat experience. In this article, I’ll share my journey of creating a simple yet effective AI-powered Bible chat app using the Gemini AI SDK and Flutter, focusing on Stacked architecture for state management and sqflite for local storage.

Conceptualizing the AI Bible Chat App

The idea was to create an application which could provide users with an interactive and personalized Bible study experience. The app would leverage AI to understand natural language queries and provide contextually relevant scripture passages, interpretations, and study materials.

The app utilizes the Gemini large language model API to process these queries and generate informative responses based on the vast amount of biblical text it has been trained on.

To enhance the user experience, I implemented an SQLite local database using the sqflite package. This allows the app to store user queries and corresponding Gemini responses. This cached data enables features like revisiting past conversations and potentially offering offline functionality in the future.

Stacked, a state management solution by Filledstacks, was chosen for its ease of use and focus on reactive programming. Stacked helps manage the application state efficiently, particularly when dealing with user interactions and updates from the Gemini API.

Choosing the Right Tools

Frontend: Flutter – A framework from Google, emerged as the ideal framework for its cross-platform capabilities and its expressive and flexible UI, enabling the building of beautiful and performant applications for iOS, Android, Web, and Desktop (MacOS, Windows, and Linux) using a single codebase.
State Management: Stacked – A reactive state management solution built for Flutter, simplifying app creation, state handling and data flow within the app.
AI Model: Gemini – A large language model from Google AI, trained on a massive dataset of text and code, allowing it to generate creative text formats and answer questions in an informative way.
Local Database: sqflite – An ORM (Object Relational Mapper) for Flutter that facilitates interaction with SQLite, a lightweight and embedded relational database engine, for storing user queries and Gemini responses on user devices.

Designing the App with Stacked

Stacked architecture allowed for a clean separation of concerns, making the codebase more readable and easier to manage. It follows the MVVM pattern (Model-View-ViewModel), which fits perfectly with the reactive nature of Flutter apps.

class BibleDataService {
  final _databaseService = locator<DatabaseService>();

  Future<List<SessionConversations>?> 
     getAllSessionsWithConversations() async {
      var allSessionsWithConversations =
        await _databaseService.fetchAllSessionsWithConversations();
    return allSessionsWithConversations;
  }
}

class BibleChatViewModel extends FormViewModel {
  final _bibleDataService = locator<BibleDataService>();
  final _logger = getLogger('BibleChatViewModel');

  List<String> get books => _books;
  List<String> _books = [];

  void fetchBibleBooks() {
    _books = _bibleDataService.getBooks();
    rebuildUi();
  }
}

class BibleChatView extends StackedView<BibleChatViewModel> {
  const BibleChatView({super.key});

  @override
  Widget builder(
    BuildContext context,
    BibleChatViewModel viewModel,
    Widget? child,
  ) {
    return Scaffold(
      backgroundColor: kcChatBackground,
      appBar: ChatAppBar(
        title: viewModel.sessionConversation?.session?.title.toString() ??
            'No title',
        onHistoryPressed: viewModel.showHistoryDialog,
      ),
      body: SafeArea(
        child: Column(
          children: [
            Expanded(
                child: ChatComponent(
              conversations: viewModel.sessionConversation!.conversations!,
            )),
            const ChatBoxComponent()
          ],
        ),
      ),
    );
  }

  @override
  BibleChatViewModel viewModelBuilder(
    BuildContext context,
  ) =>
      BibleChatViewModel();
}

Integrating Gemini AI SDK

The Gemini AI SDK was integrated to handle natural language inputs. It processed user queries and matched them with relevant Bible and scripture content, using a combination of machine learning models and a structured database of scriptures.

  GenerativeModel initializeAIModel() {
    const apiKey = 'YOUR_API_KEY';
    openModel ??= GenerativeModel(
        model: 'gemini-pro',
        apiKey: apiKey,
        generationConfig: GenerationConfig(maxOutputTokens: 1000));
    return openModel!;
  }

Local Storage with sqflite

To enhance the user experience with offline capabilities, sqflite was used for local storage. It stored user chat history with Gemini, allowing for a seamless experience even without an internet connection.

Future<void> init() async {
    _logger.i('Initializing database');
    final directory = await getApplicationDocumentsDirectory();
    _database = await openDatabase(
      '${directory.path}/bible_chat',
      version: 1,
    );
    try {
      _logger.i('Creating database tables');
      await _databaseMigrationService.runMigration(
        _database,
        migrationFiles: [
          '1_bible_chat.sql',
        ],
        verbose: true,
      );
      _logger.i('Database tables created');
    } catch (e, s) {
      _logger.v('Error creating database tables', e, s);
    }
  }

Conclusion

The development of the AI Bible chat app was a fulfilling project that combined my passion for software engineering with the power of AI. By utilizing Flutter, Gemini AI SDK, Stacked, and sqflite, I was able to create an app that not only met the technical requirements but also provided a meaningful experience to its users.

The journey doesn’t end here, though. The field of AI is constantly advancing, and there’s always room for improvement and innovation. I look forward to exploring new ways to enhance the app and bring even more value to users across the world.

This article is a high-level overview of the technical approach taken to build the AI Bible chat app. It’s intended to inspire and guide those who are interested in developing similar applications. Remember, the best technical articles are those that inform, engage, and challenge the reader to think differently about the problems they’re solving.

Here's a link to the next article titled: Flutter & Faith: Crafting an AI Bible Chat App with Stacked Architecture - Part 2

Download the APK app sample (arm64) here