DEV Community: Ayush Jaiswal

Raksham AI: Using Open-Source AI to Detect Suspicious Banking Messages

Ayush Jaiswal — Mon, 26 Oct 2026 06:36:43 +0000

Raksham AI: Using Open-Source AI to Detect Suspicious Banking Messages

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

Raksham AI is an AI-powered security project designed to help people identify suspicious banking messages, potential SMS scams, and fraudulent financial communications.

Every day, people receive messages claiming that their bank account will be blocked, their KYC has expired, or they need to verify a transaction immediately. Some messages are legitimate, while others are carefully designed to trick people into sharing sensitive information or clicking malicious links.

The problem is that distinguishing between the two isn't always easy, especially for people who aren't familiar with common fraud techniques.

That's why I started building Raksham AI.

The goal is to analyze a message, identify potential scam indicators, and provide an understandable report explaining whether the message appears legitimate or suspicious.

I'm also working on a Circle to Search-style feature that allows users to select content from their screen for analysis, making it easier to investigate suspicious messages without manually copying and pasting them.

Rather than simply returning a binary answer, the aim is to make the results useful and understandable so users can make better-informed decisions.

Demo
Project repository: [Add your GitHub repository link]
Demo video: [Add your demo video link]
Live demo: [Add your deployed application link, if available]
Code

Raksham AI is being developed with a focus on practical AI integration, accessible tools, and an architecture that can evolve as the project grows.

The backend includes a Retrieval-Augmented Generation (RAG) pipeline that uses document chunks and vector search to retrieve relevant information before generating a response.

I'm also experimenting with local language models and custom inference endpoints to make AI-powered analysis more accessible and flexible.

GitHub: [Insert your Raksham AI repository link here]

How I Built It

I approached Raksham AI as more than just a chatbot. The objective is to build a security-focused application that combines AI analysis with relevant evidence.

Here are the main components I've been working with:

Python and FastAPI: Building the backend and API endpoints for message analysis.
Ollama: Running open-weight language models locally for experimentation and inference.
Qwen2.5: Experimenting with a local language model to analyze messages and generate explanations.
ChromaDB: Storing and retrieving document embeddings for semantic search.
Sentence Transformers: Converting text into embeddings so semantically similar information can be retrieved.
Retrieval-Augmented Generation (RAG): Retrieving relevant reference material to help ground AI responses in evidence.
Banking and financial reference documents: Exploring how official rules and guidance can help distinguish legitimate communications from suspicious ones.
Android integration: Working on message analysis and a screen-selection workflow to make the functionality accessible within a mobile experience.

One important part of this project is figuring out how to make the output reliable. A language model can sound confident even when it is wrong, so a security tool needs more than a convincing explanation.

The longer-term goal is to combine message patterns, suspicious links, retrieved reference material, and AI-generated explanations to produce more useful assessments.

Raksham AI is still a work in progress, and improving the accuracy of its reports and screen-analysis feature is an ongoing part of development.

Why Does Open Innovation Matter?

For a project dealing with financial security, I don't want every part of the system to depend on a single proprietary AI API.

Open-weight models and open-source tools give me the freedom to experiment with different approaches, run inference locally, inspect the architecture, and adapt the system to my use case.

Using tools such as Ollama, Qwen2.5, ChromaDB, and Sentence Transformers makes it possible to build and test an AI pipeline without needing to send every message to a closed, third-party model.

This also creates opportunities to explore privacy-conscious processing, reduce dependence on a single provider, and eventually customize models for specific fraud-detection tasks.

Open innovation matters because security tools should be adaptable. Fraud tactics change, new scams appear, and detection systems need to evolve alongside them.

Open-source technology gives independent developers like me the ability to experiment, learn, and build solutions that would otherwise require considerably more resources.

My Agent Session

I'm currently developing and testing different parts of Raksham AI, including the RAG backend and the message-analysis workflow.

Agent session: [Add your DevRelay session link, if available]

The Lazy Payoff

The idea behind Raksham AI is simple: people shouldn't have to become fraud investigators every time they receive a suspicious banking message.

Instead of manually searching the internet, comparing financial rules, and trying to understand unfamiliar banking terminology, a user should be able to submit a message and receive a clear explanation of the potential risks.

The intended benefits include:

Less time spent investigating suspicious messages manually.
Faster identification of common scam indicators.
Easier access to explanations of potentially fraudulent communications.
A more convenient way to investigate messages directly from a mobile screen.

I'm not claiming a measured time saving or production-level fraud-detection accuracy yet. Those need to be validated through systematic testing against legitimate and fraudulent messages.

For me, the real payoff is building toward a tool that makes digital safety easier to access.

Prize Categories

[Add the eligible partner categories you are entering after checking the challenge rules.]

What's Next?

Raksham AI is still evolving. My next priorities are improving the accuracy of the generated reports, making screen-based analysis more reliable, and evaluating the system against a properly labeled dataset of legitimate and fraudulent messages.

I also want to improve how the system explains its decisions so users can understand why a message is suspicious rather than blindly trusting an AI-generated verdict.

The goal isn't to replace common sense or official bank support. It's to give people another useful layer of protection when navigating an increasingly deceptive digital world.

Building this project has been a reminder that open-source AI isn't just about running models. It's about using accessible technology to solve real problems, testing its limitations, and steadily making the result better.

That's what Raksham AI is about: making digital safety a little easier, one message at a time.

Hacktoberfest #OpenSource #AI #LLM #RAG #CyberSecurity

Done in hackathon

Ayush Jaiswal — Mon, 26 Oct 2026 06:29:27 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

The Lazy Payoff

Prize Categories

I Built InvoiceMate Local: An AI-Powered Invoice Generator That Runs on Your Own Machine

Ayush Jaiswal — Mon, 19 Oct 2026 03:16:26 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Creating invoices shouldn't feel like another administrative job.

Freelancers, independent developers, and small business owners spend time preparing invoices, organizing client details, calculating totals, and keeping track of previous documents. For someone managing multiple clients, these small tasks can quickly become repetitive.

I built InvoiceMate Local to make invoice creation simpler with the help of local AI.

InvoiceMate Local is a Python application with a Streamlit interface, local AI integration through Ollama, PDF invoice generation, and invoice history.

Instead of building another application that depends entirely on a cloud AI API, I wanted to experiment with a tool that can use models running on the user's own computer.

What can InvoiceMate Local do?

Invoice creation: Create invoices through a user-friendly interface.
PDF generation: Generate downloadable PDF invoices.
Invoice history: Keep track of previously created invoices.
Local AI integration: Use Ollama to run AI models locally.
Local-first workflow: Combine invoice management and AI functionality in an application that runs on your own machine.

The idea is simple: make a practical business tool while exploring how open-weight AI models can power useful everyday applications.

Who would pay for it?

InvoiceMate Local is designed with these potential users in mind:

Freelancers who regularly invoice clients.
Independent developers and consultants.
Small businesses that need a straightforward invoicing workflow.
People who prefer running AI tools locally rather than relying entirely on cloud services.

A future commercial version could offer additional customization, invoice templates, reporting, and other workflow improvements.

InvoiceMate Local is currently an open-source project, and its commercial potential remains something I want to explore.

Demo

Project repository: InvoiceMate Local on GitHub

Video walkthrough:

link: https://drive.google.com/file/d/1TV9M7VdsYc2OmOvt2KRqlZSob57_FocX/view?usp=drive_link

The walkthrough demonstrates the application running locally.

The goal is to show the actual workflow rather than just screenshots: opening the application, working with invoice details, generating a PDF, and accessing invoice history.

Code

GitHub Repository: jazayush/invoice-mate

jazayush / invoice-mate

InvoiceMate Local 🧾

A local-first AI invoicing assistant for freelancers and small businesses.

InvoiceMate Local combines a lightweight invoicing workflow with AI writing assistance powered by Ollama. Create invoices, improve service descriptions, draft payment emails, export professional PDFs, and track invoice status—all from a local Streamlit application.

Project status: Early-stage MVP. Review all invoice details and AI-generated text before sending anything to a client.

Why InvoiceMate?

Freelancers often spend time turning rough work notes into clear invoice descriptions and writing payment emails. InvoiceMate helps with that admin work while keeping AI inference on the user's own machine through Ollama.

It is designed for people who want a simple invoicing workflow without depending on a hosted AI…

View on GitHub

The project is built with Python and uses an MIT license.

The repository includes the application source code, dependency list, and setup documentation.

I'm sharing the project so other developers can explore the implementation, run it locally, and build on it.

How I Built It

InvoiceMate Local brings together a few tools that work well for a lightweight, locally running application.

Technology Stack

Python: Application logic.
Streamlit: User interface.
Ollama: Local AI model runtime.
Qwen 2.5 and Gemma: Models I experimented with locally.
ReportLab: PDF generation.
SQLite: Local invoice history.

Local AI Instead of a Cloud-Only Architecture

One of the main things I wanted to explore was running AI models on my own machine.

I used Ollama to experiment with locally available models, including Qwen 2.5 and Gemma. This gave me a way to integrate AI without making a paid, hosted inference API a requirement for every model interaction.

The application uses Streamlit for its interface, while ReportLab handles PDF generation and SQLite stores invoice history locally.

A Practical Challenge

Getting the application running was only part of the work.

I also wanted invoice generation and downloading to feel responsive. During development, I worked on the PDF workflow to make downloading the generated invoice faster.

This project helped me understand how local AI, a Python application, document generation, and local persistence can fit together into a usable product.

Why Does Open Innovation Matter?

For me, open innovation is about having the freedom to experiment, understand the tools I'm using, and build something useful without depending entirely on a single proprietary AI provider.

1. More Control Over AI

With Ollama and open-weight models, developers can experiment with different models and choose what works best for their hardware and application.

2. Less Dependence on Hosted AI APIs

A local inference setup can reduce dependence on per-request cloud AI fees. It also makes experimentation possible without needing a hosted model API key.

Local inference still has hardware, storage, and electricity costs, and the application may require internet access for installation or updates.

3. A More Accessible Way to Build

Open-source tools make it easier for students, independent developers, and small teams to experiment with AI-powered products without starting with a large infrastructure budget.

4. Local Processing and Data Control

Running AI locally can help users retain more control over their information. However, local execution alone does not guarantee complete privacy; the application's actual data flows and security still matter.

What I Learned

InvoiceMate Local is my attempt to turn local AI from an experiment into a practical application.

It gave me an opportunity to work with Ollama, Python, Streamlit, PDF generation, and local data storage while thinking about a problem that freelancers and small businesses encounter regularly.

I want to continue improving the project based on feedback and explore which features would make it genuinely useful in everyday work.

What's Next?

Some improvements I'd like to explore include:

More invoice templates and customization.
Better invoice search and filtering.
Additional business reporting.
Improved AI-assisted workflows.
Packaging the application to make local installation easier.

These are future ideas, not claims about features already implemented.

Prize Categories

This submission is for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

Try InvoiceMate Local, explore the code, and share your feedback!

GitHub Repository

Building a Local AI Assistant with Ollama: My Open-Source AI Journey

Ayush Jaiswal — Sun, 11 Oct 2026 05:21:42 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

Building a Local AI Assistant with Ollama

I've been experimenting with local LLMs and exploring how to build AI applications without depending entirely on hosted APIs.

For this challenge, I started building a Python-based RAG (Retrieval-Augmented Generation) pipeline using Ollama. This is an early-stage project, and I'm still exploring how to turn it into something people can use outside their screens.

What I Built

I built a basic RAG pipeline that processes documents, indexes their content, retrieves relevant passages, and uses a locally running language model to answer questions.

So far, I've implemented:

Document processing for CSV and PDF files.
Passage indexing for information retrieval.
Retrieval-augmented question answering.
Local LLM inference using Ollama.

I tested the pipeline with an exoplanet dataset containing 27,215 indexed passages. I was able to ask questions about the dataset and get answers based on the retrieved information.

This is currently a terminal-based experiment. I haven't built a frontend or completed an agent harness integration yet.

Connecting It to the Touch Grass Theme

My next goal is to explore how this local AI pipeline could support outdoor activities, such as helping people prepare for hikes, learn about nature, or access useful information when internet connectivity is limited.

These are planned features, not capabilities I've implemented yet.

Demo

Currently, I don't have a deployed demo or video demonstration.

I've tested the pipeline locally through my terminal, including indexing the dataset and querying it with Ollama.

I'll share a demonstration once I have a more complete version.

Code

The project is currently running locally on my Linux machine.

I haven't published a GitHub repository yet. I plan to organize the code and document the setup before making it available.

How I Built It

My current setup uses:

Python: For document processing and application logic.
Ollama: For running a language model locally.
RAG: For retrieving relevant information from indexed documents before generating answers.
CSV and PDF processing: For working with different document formats.

I wanted to understand how the different components fit together rather than simply sending prompts to a hosted AI API.

I'm also exploring open-source agent harnesses, although I haven't integrated one successfully yet.

Why Does Open Innovation Matter?

Open innovation gives developers the freedom to experiment, inspect implementations, change components, and build on existing work.

For a project like this, it means I can experiment with locally running models, choose different models, and explore how the retrieval pipeline behaves without tying the entire application to one hosted API.

Local inference can also help keep document contents on the user's machine, depending on how the application is designed. It gives me more control over the system and helps me learn how these applications work internally.

I'm still at the beginning of this journey, but I want to understand these technologies by building something myself.

My Agent Session

I haven't recorded an agent session yet.

Prize Categories

No partner categories selected yet.

I'll consider the relevant categories as the project develops.

This is a work in progress, and I'm sharing it at an early stage rather than waiting until everything is polished.

If you've built local AI applications or experimented with open-source agent harnesses, I'd appreciate your suggestions on what I should explore next.

hf26challenge #opensource #ai #python #ollama #rag

tryinh the post

Ayush Jaiswal — Mon, 05 Oct 2026 06:44:02 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

DEV Community: Ayush Jaiswal

Raksham AI: Using Open-Source AI to Detect Suspicious Banking Messages

Hacktoberfest #OpenSource #AI #LLM #RAG #CyberSecurity

Done in hackathon

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

The Lazy Payoff

Prize Categories

I Built InvoiceMate Local: An AI-Powered Invoice Generator That Runs on Your Own Machine

What I Built

What can InvoiceMate Local do?

Who would pay for it?

Demo

Code

jazayush / invoice-mate

InvoiceMate Local 🧾

Table of contents

Why InvoiceMate?

How I Built It

Technology Stack

Local AI Instead of a Cloud-Only Architecture

A Practical Challenge

Why Does Open Innovation Matter?

1. More Control Over AI

2. Less Dependence on Hosted AI APIs

3. A More Accessible Way to Build

4. Local Processing and Data Control

What I Learned

What's Next?

Prize Categories

Building a Local AI Assistant with Ollama: My Open-Source AI Journey

Building a Local AI Assistant with Ollama

What I Built

Connecting It to the Touch Grass Theme

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

hf26challenge #opensource #ai #python #ollama #rag

tryinh the post

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

INTRO