DEV Community: Rohan Sharma

My Docs Are Safer Than My Search History 😎

Rohan Sharma — Sun, 15 Feb 2026 10:20:01 +0000

This is a submission for the GitHub Copilot CLI Challenge: Build with AI

Hey there! Welcome back. This is my latest project that I'm super excited to share with you!

Remember that one time your friend asked you to "just quickly check" their Google Doc, and you spent 20 minutes figuring out if you had view-only or editing access? Or when your team's important document got accidentally shared with the entire internet? Yeah, me too. 😅

That's why I built Radhika's AI DocManager, a document management system that doesn't mess around when it comes to security, roles, and AI-powered features.

Live Demo: radhika-docmanager.vercel.app

What's This All About? 🤔

Imagine you and your partner have a shared notebook. But here's the twist:

You can write anything you want in your sections
Your partner can only read some sections (View Only)
Your partner can comment on other sections but not edit them (Comment)
Some pages are locked with a password because they contain surprise party plans 🎉

That's basically what this project does, but for teams and organizations!

Question for you: Have you ever accidentally deleted someone else's important document or had your document deleted by someone? How did that go? 😬

The Cool Features That'll Make You Go "Woah!" 🚀

1️⃣ Four Roles, Four Levels of Trust

Think of roles like relationship stages:

User (Dating Stage): You can only see and manage your own stuff. Can't touch anyone else's documents.
Admin (Committed Relationship): You can see everything in your organization and manage your team members. You're the responsible one now!
Super Admin (Marriage Level): Like Admin but with superpowers! You approve who joins your org, can promote people to Admin, and have elevated privileges. But you're still tied to your organization!
God (The Parent): Full control over the ENTIRE platform across ALL organizations. Can post documents to ALL organizations at once. The ONLY role with cross-org access! Ultimate power! 💪
- Important Note: God has read access to all documents across organizations for platform management, but the primary focus is on public documents and cross-org coordination. Organizations still maintain their privacy for internal operations.

Each role has a "weight" number. Higher weight = more authority. Just like how your mom outranks you when deciding what's for dinner! 😄

Important: Only God can see across organizations. Super Admin, Admin, and User are all scoped to their own organization!

2️⃣ Document Security That Actually Makes Sense

Your documents can have different classification levels:

Public: Everyone can see it (like your Instagram story)
Organization: Only your team can see it (like your company Slack)
Internal: More restricted (like your team's strategy docs)
Confidential: Top secret stuff (like your salary slip)
General: The default, casual classification

Plus, you can set access levels:

View Only: Read-only, no comments allowed (like when your partner says "just look, don't touch")
Comment: Can read and comment but not edit (like leaving sticky notes on a physical document)
Edit: Can make changes to the content
Full Access: Complete control (the relationship goals)

Want to add extra protection? Lock any document with a 9-digit password! 🔐

3️⃣ AI That Works For YOU (Not For Big Tech)

Here's the thing: I hate vendor lock-in. You know what's worse than a bad breakup? Being forced to stay with a service because you can't leave!

That's why Radhika's AI DocManager lets you bring your own API keys:

Groq (FREE tier available! Fast and perfect for getting started)
OpenAI (Premium quality)
Anthropic (Great for long documents)

Your keys are encrypted with AES-256-GCM encryption. That's military-grade security, folks! Even if someone breaks into the database, your keys are safer than your ex's secrets in your DMs. 🤫

The AI can:

Summarize documents (TL;DR generator)
Analyze sentiment (is this doc angry or happy?)
Extract key points (bullet points anyone?)
Improve writing (make it sound professional)
Translate content (hola, bonjour, namaste!)
Generate Q&A (instant study guide)
Custom prompts (ask it anything!)

Pro tip: You also get FREE local tools that work without any API key — Word Count, Structure Analysis, and Text Preview. All running in your browser!

4️⃣ Organizations That Don't Mix Like Oil and Water

Multiple organizations, complete data isolation. Think of it like this:

You have three friend groups:

College friends (Acme Corp)
Work friends (Globex Inc)
Gym friends (Initech LLC)

Each group has its own private WhatsApp group. Nobody from college friends can see what's happening in your work friends group. That's exactly how organizations work here!

To join an organization, you need an Organization Code (like a secret club password). A Super Admin must approve your membership request. No random people crashing your party! 🎊

How GitHub Copilot CLI Supercharged My Development 🚀

Okay, confession time: Building this project would have taken me MUCH longer without GitHub Copilot CLI. Let me tell you how it became my coding partner!

What is GitHub Copilot CLI?

Think of it as having a really smart friend who sits in your terminal and helps you with commands, debugging, and understanding code. You just talk to it in natural language!

How I Used It in This Project

1. Generating the Complete Supabase Schema

This was HUGE. Instead of manually writing hundreds of lines of SQL:

gh copilot suggest "generate supabase schema for document management system with organizations, users, documents, comments, and audit logs with proper foreign keys and indexes"

It gave me a complete schema structure! I just had to customize it for my needs. Saved hours of work!

2. Setting Up Row Level Security (RLS)

Supabase RLS policies are tricky. I asked:

gh copilot suggest "create row level security policy for organization isolation in supabase"

It generated the exact SQL I needed to ensure users can only see data from their organization!

3. Database Schema Debugging

When my foreign key constraints weren't working:

gh copilot explain "Why is my foreign key constraint failing between documents and profiles?"

Boom! Got the answer instantly and fixed the relationship properly.

4. Creating Storage Buckets with Policies

Setting up Supabase storage:

gh copilot suggest "create supabase storage bucket for documents with 50MB limit and access policies"

Got the complete SQL for buckets AND storage policies. No more digging through docs!

5. Complex Git Operations

Had to rebase multiple commits with conflicting changes:

gh copilot suggest "rebase last 5 commits and squash them into one"

Got the exact git commands I needed. No more Stack Overflow!

6. TypeScript Type Errors

When dealing with complex Supabase types:

gh copilot explain "Cannot find name 'UserRole' in this scope"

Instantly told me I needed to import from @/lib/supabase/types. No more hunting through files!

7. Debugging Permission Logic

When my role-based access control wasn't working:

gh copilot explain "why is my outranks function returning false for admin checking user role"

Helped me understand the weight comparison logic and fix the bug in minutes!

8. File Upload Implementation

Struggled with Supabase storage upload with progress:

gh copilot suggest "upload file to supabase storage bucket with progress tracking and error handling"

Got complete working code with progress bars and proper error handling!

9. Understanding bcrypt Hashing

When implementing password security:

gh copilot explain "difference between bcrypt compare and hash and when to use each"

Clear explanation that helped me implement secure authentication correctly!

10. Deployment to Vercel

Deploying with all environment variables:

gh copilot suggest "deploy next.js app to vercel with environment variables from .env file"

Got the proper CLI commands with all the flags needed!

11. Testing Database Queries

When testing complex SQL with multiple JOINs:

gh copilot explain "how to test row level security policies in Supabase without deploying"

It explained the whole local testing process step by step!

But do you know? I've even implemented most of the frontend with it as well. 😎

Why Copilot CLI is a Game Changer

No Context Switching: Stay in your terminal, no need to open browser
Natural Language: Ask questions like you'd ask a friend
Project-Aware: It understands your codebase context
Instant Answers: Faster than googling and reading 10 different answers

Real Talk: I probably saved 10-15 hours of googling, debugging, and trial-and-error just by having Copilot CLI help me with terminal commands, git operations, and understanding error messages.

If you're not using it yet, you're missing out! It's like having a senior developer on speed dial. 🎯

The Tech Magic Behind the Curtain 🎩✨

(Don't worry, I'll keep it light!)

Built With Love Using:

Next.js 14 (App Router)
Supabase (PostgreSQL database + storage)
TypeScript (because typos are for noobs)
Tailwind CSS + shadcn/ui (for that crispy dark mode 🌙)
Bun runtime (faster than your morning coffee hitting your system)

Security Layers:

Passwords: bcrypt hashing (can't crack it even if you try)
API Keys: AES-256-GCM encryption (Fort Knox level)
Document Passwords: Another layer of bcrypt (double protection!)
Organization Isolation: Complete data separation (no mixing allowed)

Document Support:

Upload pretty much anything:

PDF (with embedded viewer)
Word docs (auto text extraction!)
Plain text, CSV, Markdown
HTML, JSON, RTF, ODT
Even Excel and PowerPoint (why not?)

File size limit: 50 MB per document. That's like... a LOT of cat pictures! 🐱

The Boyfriend-Girlfriend Analogy That'll Make You Understand Permissions 💑

Let's say you and your partner are working on planning a surprise party:

User Role (You):

You can create your own to-do list
You can only see your own tasks
You can't see or touch your partner's secret guest list

Admin Role (Your Partner who's more organized):

Can see both your lists (within your organization)
Can delete tasks from User-level people
Can manage who's invited to the planning team
But can only see YOUR organization's party, not other orgs

Super Admin Role (The Senior Party Planner):

Like Admin but can also approve new members joining YOUR organization
Can promote people to Admin within your org
Has elevated privileges for your organization
But still can't see OTHER organizations' parties (that's God's job!)

God Role (The Person Whose Birthday It Is):

Knows about ALL surprise parties EVERYWHERE (cross-org access!)
Can access any planning doc in any organization for platform management
Can post announcements to all party groups at once
Bypasses all password locks (it's their birthday, after all!)
The ONLY role that can see across all organizations!
But remember: God is the platform administrator, not Big Brother watching everything. The focus is on managing public documents and cross-org coordination, while respecting organizational privacy.

See? Not so complicated! 😊

Real-World Use Cases

For Teams:

Store company policies (Organization classification)
Share meeting notes (Comment access)
Collaborate on proposals (Edit access)
Lock sensitive HR docs (Password protection)

For Content Creators:

Draft blog posts (Draft status)
Get feedback from editors (Assign reviewers)
Publish final versions (Published status)
Archive old content (Archived status)

For Students:

Store class notes
Collaborate on group projects
Share study guides
Keep research papers organized

Question for you: What would YOU use this for? I'd love to hear your use case! Drop it in the comments! 💭

The Journey (AKA The Fun Part) 🎢

Building this was like assembling IKEA furniture while blindfolded. Here's what I learned:

Challenge #1: Role-Based Access Control

Creating a system where User < Admin < Super Admin < God without breaking everything? HARD. I used a "weight" system (User = 10, Admin = 50, Super Admin = 75, God = 100). Simple math, complex implications!

Challenge #2: Organization Isolation

Making sure Acme Corp never accidentally sees Globex Inc's documents? I had to filter EVERYTHING by organization. Every. Single. Query.

Challenge #3: Encryption That Doesn't Break

Encrypting API keys is easy. Making sure you can decrypt them later? That's the trick! Used AES-256-GCM with unique IVs for each key. Sounds fancy, works perfectly!

Challenge #4: God's Multi-Org Publishing

When God creates a document for "All Orgs", the system:

Uploads the file ONCE to storage
Creates a document record for EACH organization
All records point to the same file
When God changes the status, ALL copies update together

It's like posting on all your social media at once, but harder!

The Tech Implementation (For My Developer Friends)

Permission Checking:

export function outranks(roleA: string, roleB: string): boolean {
  return getRoleWeight(roleA) > getRoleWeight(roleB);
}

export function isAtLeast(roleA: string, roleB: string): boolean {
  return getRoleWeight(roleA) >= getRoleWeight(roleB);
}

Simple, elegant, effective!

Document Deletion Logic:

User can delete: Own docs only
Admin can delete: Own + User docs (Admin outranks User)
Super Admin can delete: Own + User + Admin docs
God can delete: Own + any public document

AI Action Flow:

User clicks an AI action
System decrypts their API key in memory (never stored decrypted!)
Sends document content to AI provider
Returns result to user
Result NOT stored (privacy first!)

Organization Membership:

New user registers with Organization Code
Account created with "pending" status
Super Admin approves or rejects
If approved, user gets full access
If rejected, user can't log in

Clean workflow, no confusion!

Try It Yourself!

Live Demo: https://radhika-docmanager.vercel.app/

Documentation: https://radhika-docmanager.vercel.app/docs

Want to test it locally? Here's the speed run:

Clone the repo from GitHub
Set up Supabase project (free tier)
Copy .env.example to .env and fill in your credentials
Run bun install && bun dev
Visit http://localhost:3000/api/seed to get demo accounts
Log in and start creating documents!

Demo accounts (all use password Password123!):

god@system.local - God role (platform-wide access!)
superadmin@acme.com - Super Admin (approve memberships!)
admin@acme.com - Admin role (manage your team!)
user1@acme.com - Regular user (the everyday experience)

Or try the live app: radhika-docmanager.vercel.app

Check out the full documentation for setup details!

What's Special About This Project?

1. Security First

Most projects add security as an afterthought. I built it from day one. Encryption, hashing, isolation — the works!

2. No Vendor Lock-In

Your API keys, your choice. Switch providers anytime without losing data.

3. Real Enterprise Features

Multi-org support, approval workflows, audit logs, reviewer assignments — this isn't a toy project!

4. Actually Good UX

Dark mode that doesn't hurt your eyes. Clean interface. Logical workflows. I actually USED it while building it!

5. Named After Someone Special

Radhika's DocManager is named after Radhika Sharma. Built by Rohan Sharma (yes, it's me). Want to know more about Radhika? Find the secret page in my portfolio. ❤️

Rohan Sharma - Software Developer, Professional Blog Writer and UI/UX Designer

Explore the portfolio of Rohan Sharma, featuring cutting-edge software projects, insightful blogs, and creative UI/UX work.

rohansrma.vercel.app

6. Built with GitHub Copilot CLI

The entire development process was supercharged by GitHub Copilot CLI; from debugging complex database queries to writing deployment scripts. It's like pair programming with an AI! 🤖

Why This Project for the GitHub Copilot CLI Challenge? 🏆

This challenge is all about showcasing how GitHub Copilot CLI enhances the development process, and boy, did it ever!

The Challenge: Build an AI-powered, multi-tenant document management system with enterprise-grade security.

The Reality: That's A LOT of complexity; database schemas, encryption, role hierarchies, file uploads, organization isolation, and more.

The Solution: GitHub Copilot CLI became my development companion, helping me:

Debug complex SQL queries and foreign key constraints
Generate secure encryption keys and understand crypto operations
Navigate git operations when managing multiple feature branches
Understand error messages and fix bugs faster
Write deployment scripts and environment configurations

The Result: A production-ready application deployed at radhika-docmanager.vercel.app with features that would normally take months to build!

Without Copilot CLI, I would have:

Generate the entire Supabase schema from a single prompt describing my data model
Create Row Level Security policies for organization isolation automatically
Spent hours googling obscure error messages
Made security mistakes in encryption implementation
Struggled with git conflicts during feature merges
Wasted time reading documentation for every command

I've even implemented most of the frontend with it. Ehehe.

Instead, I focused on building features and solving real problems while Copilot CLI handled the "how do I do this?" questions instantly.

That's the power of AI meeting the command line! 🚀

Final Thoughts

Building Radhika's AI DocManager was a rollercoaster. There were moments of "WHY ISN'T THIS WORKING?!" and moments of "OMG IT ACTUALLY WORKS!"

But you know what? Creating something that helps teams manage documents securely while leveraging AI (without selling their soul to Big Tech) feels pretty amazing.

If you've made it this far, thank you for reading! You're awesome! 🌟

Star the Github Repo 🌠

Try the project, break it, suggest features, report bugs, I want to hear it all!

And if you're wondering why it's called "Radhika's DocManager", it's named after Radhika Sharma, someone special whose memory inspired this project. Sometimes the best projects come from the heart. ❤️

Links & Contact

Live App: https://radhika-docmanager.vercel.app/
Documentation: https://radhika-docmanager.vercel.app/docs
GitHub Repo: RS-labhub/AI-DocManager
My Portfolio: rohansrma.vercel.app
Email: rs4101976@gmail.com
LinkedIn: Rohan Sharma
X/Twitter: @rrs00179

Try the live app and let me know what you think!

Thank youuuuuuuuuuuuuuuu for reading! ❣️

Creating a Chatbot that actually Stands Out! (vibe coded version)🦖

Rohan Sharma — Thu, 29 Jan 2026 05:04:47 +0000

Hi there,

As I promised at the start of this year, I'm fulfilling my commitment. 😆

In this blog, I will discuss how you can create a chatbot far better than the rest of the other chatbots around. This blog is mostly for learning, so keep an eye at every section. I will be referencing the Chatbot I've created. Btw, my chatbot is called "Radhika", so I will call it by its name itself.

Radhika

Radhika is a versatile AI chatbot designed to assist with a wide range of tasks, from answering questions to providing recommendations and engaging in casual conversation.

radhika-sharma.vercel.app

Try it out, give feedback and suggestions, request changes, etc,.

It's open-source as well, so leave a github star if you loved it.

Note:
Switch to GROQ in case Gemini encounters an error. Currently, I'm using the free plan, so the tokens might get exhausted.

Let's start building our Chatbot!

Before doing anything else, decide on your tech stack.

There are many ways to build a chatbot, and plenty of stacks you can choose from. Pick the one you are most comfortable with.

For Radhika, I used TypeScript, which is a typed version of JavaScript. I built it using Next.js so both the frontend and backend live in the same project. This also makes deployment simpler since everything is deployed together. Simple and efficient.

(To be honest, vibe coding NextJS apps is easier, and the AI tools do a great job)

Design it.

If you're a designer, then design the bot in applications like Canva or Figma.

If you want to see Radhika's design, please check this radhika_figma_design.

If you're not a designer, describe the prompt as much as you can with all the details you've in your mind. Don't think about the features, think about the design.

Remember, our first target should either be the backend or the frontend. You can start with any of them, but I usually suggest creating the frontend first and then working on the backend.

For a start, I'm adding a sample prompt for this, but before that I need to cover an important question, i.e., WHERE TO ADD THIS PROMPT?

You can add the prompts to generate the frontend in these platforms:

But since we are going to create a full-stack chatbot, I suggest to use claude-opus-4.5 model in your IDE. And if you

If you're a student, try to avail the Github's Student Pack and then use your IDE + Github Copilot. (you'll get a hell lot of free credits to most of the models, including claude-opus-4.5 create anything good.)

Here's your GO TO PROMPT to build your first Chatbot:

### Agentic UI Replication Prompt (Design + Three.js + Maintainable Code)

You are a senior product designer and frontend engineer with strong experience in **scalable UI systems**, **Three.js**, and **long-term maintainable codebases**.

Your task is to replicate a **AI assistant ChatBot** with a **three-column layout**, glassmorphism, and subtle real-time visualizations, while keeping the implementation **clean, readable, and modular**.

## Core Principles

* Prioritize **readability over cleverness**
* Small, focused files
* Clear separation of concerns
* No duplicated logic
* All visuals, logic, and data flows should be easy to reason about

## Project Structure Guidelines

* Organize the codebase by **feature, not by file type**
* Each major UI section should live in its own folder
* Each folder should contain:

  * One main component
  * One styles file
  * Optional subcomponents
  * A clear entry point
* Three.js logic must be isolated from UI layout code
* Avoid large monolithic components

## Overall Visual Style

* Dark navy to near-black gradient background
* Glassmorphic cards with subtle blur and soft inner glow
* Rounded corners throughout
* Accent color: cyan / electric blue
* Premium, calm, futuristic AI aesthetic
* No harsh borders, no visual noise

## Left Sidebar (Assistant Identity + Modes)

* Fixed vertical glass panel
* Sections split into small components:

  * Assistant identity header
  * Mode selector list
  * Unlock CTA card
  * Quick actions list
* Active mode visually highlighted with soft cyan glow
* All icons and labels driven from a single config file

## Center Panel (Primary Interaction Area)

### Header

* Mode title
* Model badge
* Minimal action icons
* Primary CTA button
* Header logic isolated from content logic

### Core Visualization (Three.js)

* Use a dedicated Three.js scene module
* Render an abstract **circular particle system**
* Particles form a softly rotating sphere or neural cluster
* Color palette limited to cyan, blue, and soft white
* Animation:

  * Slow rotation
  * Subtle breathing or noise-based movement
* Interaction:

  * Light cursor-based parallax
* The canvas must be:

  * Self-contained
  * Easily removable or replaceable
  * Not tightly coupled to UI state

### Main Content

* Headline and subtext in a simple content component
* Quick action pills rendered from a data array
* No hardcoded UI strings inside logic

### Input Section

* Input bar broken into:

  * Text input component
  * Left action icons
  * Right action icons
* Icons reusable across the app
* Keyboard behavior handled in a dedicated hook or utility

## Right Sidebar (Analytics & Activity)

### Activity Matrix (Three.js)

* Separate Three.js scene from layout code
* Visualize activity using:

  * Nodes and connecting lines
  * Temporal motion paths
* Minimal neon wireframe aesthetic
* Motion should feel ambient, not informational
* Scene must support pausing when off-screen

### Stats & Mode Usage

* Each stat card as its own component
* Mode usage bars driven by data, not hardcoded values
* Visual styles shared via common tokens

### AI Status Section

* Reusable status row component
* Indicator colors derived from state mapping
* No inline conditional styling

## Three.js & Performance Constraints

* Keep particle counts low and configurable
* Centralized animation loop management
* Clean disposal of geometries and materials
* requestAnimationFrame usage should be controlled and predictable
* WebGL failure should gracefully fall back to static UI


## Maintainability Constraints

* No inline styles for complex layouts
* No deeply nested components without justification
* Use clear naming conventions
* Comments should explain intent, not obvious behavior
* Any complex logic must be documented at the top of the file

## Final Goal

The result should feel like a **production-ready AI dashboard** that is:

* Visually calm
* Technically elegant
* Easy to extend
* Easy for another engineer to understand within minutes

Make some iterations until you reach a satisfactory level. (Satisfaction doesn't mean you need the best out of the best. It should be something you think is good enough)

Start implementing the Core Features

And since we are creating it through vibe coding, let's go through a little-little code only. Want no code? Skip this section.

In your chatbot, you can add multi-provider support or you can choose only a single provider. In my case, I love to have multi-provider support because this allows the user to switch to any model they want.

The following diagram represents the implementation I've done in Radhika:

But the most important part than this is to parse the request sent by the user.

The request handler begins by parsing the JSON body from the incoming POST request:

const body = await req.json();
const { messages, mode = "general", provider = "groq", apiKey } = body;

messages: The conversation history sent by the client.
mode: Determines which system prompt to use (e.g., bff, learning, etc.). // totally depends on you if want to add multiple modes
provider: Specifies the AI backend to use (groq, openai, claude, gemini, or whatever provider you're using).
apiKey: Required for OpenAI and Claude if a user key is needed.

Assign the Prompt
Add a system prompt on how you want your chatbot should behave and talk about. You can also link it with a KB (knowledge base) or create your own mini knowledge base to make your bot more specific to something.

I've not implemented this as I wanted my Radhika to be generic and serve as a good template for someone like you.

If you're also adding multi-provider, then route to the correct provider. Each provider has custom logic to instantiate the model, handle errors, and stream the response using:

await streamText({...})

Looking for a prompt? Here it is: (add this in the same chat session or the create one)

### Agentic Backend Architecture Prompt

You are a senior backend engineer designing a **production-ready AI chat backend** with **multi-provider model support**, clean architecture, and long-term maintainability.

Your goal is to build a backend that powers an AI assistant similar to **Radhika**, where users can switch models dynamically while keeping the system simple, extensible, and readable.

## Core Backend Principles

* Clear separation of responsibilities
* No provider-specific logic inside request handlers
* Easy to add or remove AI providers
* Streaming responses by default
* Minimal abstractions, no over-engineering
* Code should read like documentation

## Request Handling Flow

* Use a single POST endpoint for chat interactions
* Parse the incoming JSON request at the boundary

`'``ts
const body = await req.json();
const { messages, mode = "general", provider = "groq", apiKey } = body;
`'``

* `messages`: full conversation history from the client
* `mode`: determines which system prompt to apply
* `provider`: selected AI backend
* `apiKey`: optional user-supplied key for providers that require it

Validation should happen immediately after parsing and fail early with clear errors.

## Prompt Management

* System prompts must be centralized
* Store prompts in a dedicated module or folder
* Map prompts by mode name
* Avoid hardcoded prompt strings inside logic
* Allow future expansion into:

  * Knowledge base injection
  * Context enrichment
  * Mode-specific behavior tuning

If no custom knowledge base is attached, default to a generic assistant prompt suitable for broad usage.

## Provider Routing

* Use a provider router layer
* Route requests based on the `provider` field
* Each provider must live in its own isolated module
* No shared state between providers

Each provider module should:

* Instantiate its own client
* Normalize input messages
* Handle provider-specific errors
* Support streaming responses using:

`'``ts
await streamText({ ... })
`'``

The request handler should never know how a provider works internally.

## Streaming Architecture

* Streaming must be first-class, not optional
* Keep streaming logic abstracted behind a common interface
* Providers should emit tokens in a unified format
* Handle disconnects and stream cleanup gracefully

## File Organization Guidelines

* Organize by responsibility, not file type
* Suggested structure:

  * `/routes` for request handlers
  * `/providers` for AI provider implementations
  * `/prompts` for system and mode prompts
  * `/utils` for shared helpers
  * `/types` for request and provider contracts
* One provider per file
* One responsibility per file
* No oversized files

## Error Handling

* Normalize all provider errors
* Never leak raw provider error messages to clients
* Return consistent error shapes
* Log provider-specific details internally

## Extensibility Rules

* Adding a new provider should require:

  * One new provider file
  * One registration entry in the provider router
* No changes to the core request handler
* No breaking changes to existing providers

## Maintainability Constraints

* Avoid deeply nested conditionals
* Prefer early returns
* Use explicit naming over clever abstractions
* Add comments only where intent is non-obvious
* Keep configuration and logic separate

## Final Goal

The backend should feel like a **reference implementation** that:

* Supports multiple AI providers cleanly
* Streams responses efficiently
* Is easy for other developers to fork
* Serves as a strong template for building AI chat systems

Adding a Database (optional)

Though this is totally optional, if you want to add persistent storage to the user chats that can be retrieved later, then add a database. Or if you want to track your bot users, you can create a database.

I used it to implement both.

Initially, I was using the Supabase free tier, but I was hitting the limits, and my app was becoming stale. Then I switched to Appwrite. Both are totally different; one is SQL, while the latter one is NoSQL. Although use node-appwrite package to skip the manual schema add-ons.

If you want to create something similar to what I've created, then modify or replicate setup_appwrite_schema.

Looking for a prompt? Think your logic first and write it, and then ask ChatGPT to convert it into an agentic prompt. You will enjoy this!

You're so done!

This is how simple to create a full-fledged chatbot with a professional codebase.

Once done, you can upload it to GitHub and then host it on serverless platforms like Vercel.

If that's not enough to you, then start with Radhika and modify as much as you can.

RS-labhub / Radhika

Radhika is a multi-model AI assistant built for your mood and friendship 💞

Radhika

A modern AI assistant that adapts to how you work and think. Multiple modes, multiple models, one seamless chat experience. Features multiple LLM providers, image generation, voice interaction, and persistent chat history.

Try now: https://radhika-sharma.vercel.app

Detailed Explanation

Preview	Description
	Blog Post Read the blog for in-depth explanation.
	YouTube Demo Coming soon.

Features

6 Chat Modes: General, Productivity, Wellness, Learning, Creative, BFF
Multi-Provider LLM: Groq, Gemini, OpenAI, Claude
Image Generation: Pollinations, DALL·E 3, Hugging Face, Free alternatives
Voice: Speech-to-text input & text-to-speech output
Auth & Persistence: Appwrite auth with chat history & favorites
UI: Light/dark themes, modern & pixel UI styles

Quick Start

git clone https://github.com/RS-labhub/radhika.git
cd radhika
bun install   # or npm install
bun run dev   # or npm run dev

Open: http://localhost:3000

License

MIT License - see LICENSE

Built with ❤️ by Rohan Sharma

⭐ Star • 🐛 Issues • 🗣️…

View on GitHub

I have implemented a lot of other features like voice recognition and synthesis using WebKit and Eleven Labs, image generation using pollination.ai, openai, gemini, huggingface models, etc,. (pollinations ai and HuggingFace models are free to generate images/videos/texts/etc,.)

Conclusion

Creating a chatbot is super-easy and doesn't need much knowledge. It's just like texting messages to agents.

However, you need prompting skills to get the product in a very less time.

Want some prompting tips? Comment or reach out to me!

Before sharing the ways to reaching me, I want you to star the GitHub repo of Radhika.

Star Radhika on Github 🌠

Find the Live Demo here: https://radhika-sharma.vercel.app/

Want to connect with me? Visit my Portfolio, contact's page.

2025 in Review: Growth, Grief, and the Cost of Momentum

Rohan Sharma — Wed, 31 Dec 2025 04:15:22 +0000

Hey there,

I know, I know it's been a long time since I last posted or wrote anything. It might be possible that you are either pissed off at me or have literally forgotten me. In both cases, I apologize.

So, why was I dead? Possible reasons:

being very very very busy at work
being depressed
lost willingness to write
lose interest in everything
no reasons, just trying to coverup myself with lies

Before you go ahead and read the rest of the blog, please select an option from above and write it down in the comment section. Let's see what you think!

Let's start this blog by justifying myself.
The actual reason for me being dead was -- several. I will write my 2025 wrap-up and then wind up the reasons if you still didn't get it while reading it.

Starting with January 2025. The year began with a big change. I joined LLMWare as a devRel Engineer and am still serving to Quira as Community Moderator. February was already on my mind because of the GATE exam (a national exam in India for PG admissions). So, I also started to prepare for that. The weather stayed kind, which helped more than I realized at the time. Oh btw, I forgot, I went to college every day just to reach the 75% attendance milestone/.

February 2025. This was the month things started to feel real. I had the GATE exam in the first week, and once it was over, I shifted fully back to work. I had taken quite a few days off earlier and did not want to slow things down further. On February 8, 2025, I consciously decided to make llmware my P0 and commit to it properly. A few days later, my university exams began. It was work during the day and exams around it. I managed. In the middle of all that, I lost something I can never get back - a friend. It was 16th Feb, 2025.

After a rough start, 2025 rolled into March. Things began to move with more seriousness. I started giving more of my time to work. College was sucking, as usual. Staying busy became a way to escape the matrix of overthinking. Along the way, I missed a few family moments, and by the end of the month, my brothers left home for work. For the first time, the house was quiet. Not for a day, but for DAYS. Professionally, things were on track. Personally, I was starting to fall behind.

April 2025 started. llmware started gaining real momentum on GitHub. Work became my default state. I began keeping my distance from people and spending more time alone. During the month, I met the Founder & CEO of devEco. We had a few meaningful conversations, and I decided to take on part-time work with them.

It's May 2025 now. Things accelerated at llmware. I was putting in more hours than ever. Alongside that, I officially joined devEco as well. Suddenly, my days were split between college, llmware, quira, and devEco. Even then, most of the conversations were still with myself. With still some time left to spare, I pushed myself to participate in a DEV Challenge, the authorization challenge.

Now, it's June 2025, the biggest month for me. I pushed past every limit and worked relentlessly. On non-college days, I was putting in 14 to 15 hours. On college days, around 8 to 9. I led the documentation for llmware’s major product announcement, Model HQ. The work spanned two months, but most of it came together in June. I also won the DEV Challenge I had participated in the previous month.

Professionally, I was at my peak. And it was at that peak that I started forgetting everything else. I barely ate because I simply did not think about it. The intensity was self-imposed. There was no pressure from either company. In fact, I was repeatedly asked to slow down and rest. I did not listen. During this stretch, I also wrote five blogs and scheduled them through early July.

Sadness followed me through it all. When the Founder & CEO of Quira told me the company was winding down, it shook me deeply. Quira was my first job, and the place where I learned how to build and belong.

July 2025 started with university exams. I slowed down at work, not because of the exams, but because I was quietly losing interest, even though I kept showing up and delivering. Exams themselves never bothered me much. What weighed heavier was going to college every day. I am a one nighter. I usually study for three to four hours and then sit for the exam. Somehow, I cleared everything with zero backlogs.

Quira was officially closed now. I gifted the Founder & CEO with this. He loved it.

Around the same time, one of my brothers decided to resign from his job. He was struggling with the food and climate of the region, and it had finally caught up with him.

August 2025. Happiness began to return, slowly. My brothers came back. One for good, to prepare for what was next, and the other just for the holidays. I was still hoping for a comeback from that friend, but it never happened. The hardest part was seeing each other every day in college, like strangers.

I started working again like a normal human being, and for the first time in months, I had some spare time. Around then, a former DevRel from Quira reached out and asked if I could help at his current company. He was someone who had taught me a lot. I knew he did not really need help. He was trying to help me instead. I did not say no.

That is how I joined Tessl as a part-time DevEx Engineer. Once again, I was working with three companies. This time, the work was different, harder, and more demanding in its own way. I stopped thinking too much about myself and kept moving forward.

My birthday month, September 2025. I was born on September 1. Fun fact, World War II also officially began on that day. Strange coincidence. Overall, it was a good month. I enjoyed working at my new company, even though it was more demanding than anything I had done before. I had never worked with so many people at once. The team at Tessl is filled with well-known names, and I genuinely loved being part of it. Life felt steady again.

October 2025. This was the first month when I didn't work at llmware at all. Things were moving internally, and we were all waiting. I ended up with a break, but I did not really stop. I started working on something else, still under wraps (yes, a secret). I also updated one of my projects, Radhika, and launched version 2.0. By the way, version 3.0 is coming in a few days as well. The month was also filled with festivals, and for once, I celebrated them properly.

And it's November 2025, another exam month. I slowly resumed work with llmware, tessl, and devEco continued as usual. But somewhere along the way, I lost interest in work itself. It started to feel boring. I had my 3rd university exam this month. Around this time, something shifted in me. I stopped feeling much of anything. No excitement, no fear. Just a quiet numbness. My circle became smaller than it had ever been. But overall, it was good.

Lastly, December 2025. I was fully back at work, almost like before. This time, though, I had more holidays than usual. I am still on break until January 1, 2026. The time off did something unexpected. It forced me to notice what I had lost this year, what I wanted but never paused to ask for. Loneliness showed up quietly. Real FOMO too. Feelings I had avoided all year finally caught up.

At this point, I cannot clearly say whether I am happy, sad, exhausted, lost, or simply alone. Maybe it is a mix of everything.

Have you ever gone through a phase like this?

Now's let me write what you're most interested in reading

Leaving personal life in a corner, let's talk about the professional growth I've achieved this year.

Building Community and Trust at Quira:

Engaged in activity and participation in Quests
Handled the community in hard times.
Helped many members get started and ship their first projects on Quira through one-on-one sessions.
Proposed ideas that significantly improved community participation, communication, and retention.
Built a warm and approachable community space where members felt comfortable reaching out. I was never seen as a distant or formal figure, but as a trusted colleague, which I truly valued.
Demonstrated strong developer advocacy by supporting both the product and the people using it.

What I Built and Shipped at LLMWare:

Elevated LLMWare's GitHub activity. (6,500+ Stars and 2,000+ Forks Organic Farming in 6 months)
Increased the awareness of SLMs.
Created a whole new website. (A newer version is coming soon)
Wrote documentation for Model HQ (a llmware's product) and hosted it. (got great feedback from senior developers)
Involved in QA and testing of Model HQ.
Delivered over 15 high-quality contents.
Contributed to the social presence of llmware.

Growing devEco's Developer Presence:

Managed socials across multiple platforms for devEco, devEco products, and devEco clients.
Achieved a great percentage of increase in activities like reactions, comments, reposts, and impressions.
Sparked active conversations through thoughtful content, up from almost none.

Strengthening the Developer Ecosystem at Tessl:

Strengthened the AIND ecosystem by improving the Landscape platform, fixing major bugs, refining categories, and adding new tools consistently.
Enhanced content operations through automation projects and streamlined publishing workflows.
Delivered high-quality research, carousels, and weekly trending tool updates that improved visibility and engagement across developer channels.
Provided cross-functional support to improve UX, data quality, scraping workflows, and overall product reliability.

I am sure I have not captured everything here, and that is okay. What matters is that I know how much I worked, and that I gave my best to everything I was part of. I do not know if I will continue on the same path, but for now, I am not worried about it.

Things I loved the most!!!

There were a lot of moments this year that I loved a lot. Let's start!

At Quira, I did not just meet people. I made a real friend circle. And I believe this deeply: when someone reaches out to you as a friend and shares their feelings and pain points, it means you have occupied a special place in their heart. That feeling is rare, and I will always value it.

LLMWare. Ahh. I honestly do not have enough words for this one. I met some incredibly sharp senior developers through LLMWare. Since I am under NDA, I cannot share much, but this experience opened doors to many Silicon Valley giants for me. More importantly, this was the first time I worked on a real product at a very early-stage startup. Working closely with the CEO and CTO felt natural and calm. They are kind, thoughtful, and genuinely great people to work with.

devEco filled me with sessions of laughter, joys, arguments, and whatnot! The founder is insanely cool and welcomes everyone with warmth. Becoming a core devEco member is a different kind of fun. He talks to me, teaches me, appreciates me when I do something right, and corrects me when I make mistakes. Interestingly, I didn't made much mistakes. I have 90% appreciation in my hands. Ehehe. But I must say, meet with this human once and you won't regret it.

Tessl was the biggest surprise. I was honestly hesitant at first. There were a lot of people, and in the past, I had only worked with 3 or 4 at a time. Being a newbie in such an environment hits differently. But guess what. It was smooth. Really smooth. A huge thanks to the DevRel at Tessl. This guy taught me a lot and supported me constantly. He is the person I feel most comfortable with. I can even talk to him about my personal life with ease. He speaks, shares ideas, listens to ideas, has zero ego or arrogance, treats everyone equally, always helps others, travels way too much, and still manages everything.

And not just him. The entire Tessl team is welcoming and amazing. I even got to work with the Father of DevOps himself, and he even appreciated my work(ehehe). That one stays with me.

What I Achieved!!!

Well, I achieved a lot of things. But there are some things beyond work that matter just as much.

I know most of you want to know how much money I made. Of course, I am not going to tell that. But you can assume. Let me know in the comments. I will say this though. I earned a good amount. And now, I want more. I already have plans for 2026. Or maybe not. I am a moody guy. My plans change often.

Apart from money, I gained a lot. We renovated our house. It is still not fully done. Two more months to go. We also bought a lot of furniture, although that part feels less special since we already have a family business around it.

I also got my Aloo (Mr. Potato). See below. Cute, right? Thanks to Cloudinary.

Beyond money and things, I earned something better. Respect. Trust. Value. Most importantly, I unlocked an intense learning mode. Once it switches on, it is hard to turn off.

Seems like I told everything I needed to tell. For those who still want to know the actual reason for my being dead are:

I lost my interest in almost everything.
Doing work is now boring for me.
I was a bit sad.

I do not want to write everything again, and I do not want to summarize it either. But somewhere above, these were the reasons.

Before ending, I want to thank my friends. I will not take names properly, but if you are reading this, you already know who you are.

Thanks to my college friend, SK. Without him, I would never have cleared my college exams or survived college life. We spent almost all our time together. Being single, searching for someone, then running away. He can be brainless, but not brain-rotted. A good guy with intense slang specialization.
Thanks to HG. A person I have never met in real life. But if you are not in a good mood, one single text can turn into World War III. Good, kind-hearted, always listens. Extra thin and weak human. I will not say much, else WW IV will start. But thank you for always being there.
Thanks to Sam for being Same Sam. Ultimate mad and animal human. I do not know what to say about you. Take care, you sick human. And thanks for being there.
Extending my gratitude to Dishu and Piliya. Both are placed. Both are talkative. Both get angry for no reason. Both are kind and always text me for anything. Also, neither is a cute human. Thank you, guys.
Thanks to my elderly sister NG as well. Overaged person with professional traumas. Best in arguments and worst in winning them. LOL. Thank you.
And the last guy, KOS. I worked with him. We talked about work for 1% of the time and movies, series, and heroines for 99%. Thanks for helping me debug bugs that were already fixed.
Thanks to SK as well, whom I lost this year. You've helped me a lot. Those were the happy days. Happy life ahead!

Again, do not take my words too seriously. But if you do, you are already a great person 😂

Thanks for being there.

Before I wrap this up, one last thing.

If you ever feel like knowing more about me, or just want to talk about work, life, random ideas, or nothing in particular, you can reach out to me anywhere below. I am usually around, and I genuinely enjoy conversations more than formal networking.

My portfolio: https://rohan-sharma-portfolio.vercel.app
X: https://x.com/rrs00179
LinkedIn: https://www.linkedin.com/in/rohan-sharma-9386rs/
GitHub: https://github.com/RS-labhub

No pressure to follow or connect. Just putting this here.

That is all from my side. Thank you so much for reading till here. I will be active from next year and keep delivering good content.

I forgot to ask, how did your year go?

How to Create a Local Chatbot Without Coding in Less Than 10 Minutes on AI PCs

Rohan Sharma — Wed, 02 Jul 2025 04:10:07 +0000

🔖 No cloud. No internet. No coding.
🔖 Just you, your laptop, and 100+ powerful AI models running locally.

Imagine building your own chatbot that can answer your questions, summarize documents, analyze images, and even understand tables, all without needing an internet connection.

Sounds futuristic?

Thanks to Model HQ, this is now a reality.

Model HQ developed by LLMWare, is an innovative application that allows you to create and run a chatbot locally on your PC or laptop without an internet connection. Best of all, this can be done with NO CODE in less than 10 minutes, even on older laptops up to 5 years old, provided they have 16GB or more of RAM.

In this guide, we’ll walk you through how to create your own local chatbot using Model HQ ; a revolutionary AI desktop app by LLMWare.ai. Whether you’re a student, developer, or a professional looking for a private and offline AI assistant, this tool puts the power of cutting-edge AI models directly on your laptop.

Let’s break it down.

If you want to know about Model HQ in detail, then read the blog below:

Rohan Sharma for LLMWare

Jun 27 '25

How to Run AI Models Privately on Your AI PC with Model HQ; No Cloud, No Code

#showdev #ai #security #nocode

Comments 17

5 min read

Step 1: Download Model HQ

Model HQ is an AI desktop application that allows you to interact with over 100+ top-performing AI models, including large ones with up to 32 billion parameters — all running locally on your PC.

Unlike cloud-based tools, there’s no internet required, and your data never leaves your machine. That means more privacy, better speed, and zero cost for each query you run.

In this blog, we will be looking into the CHAT feature of Model HQ that helps us to create a chatbot running locally on our machine.

First, get the app.

👉 Download or Buy Model HQ for Windows

Not ready to buy? No problem.

👉 Join the 90-Day Free Developer Trial

Once installed, you’ll have access to an interface that feels like your own AI control panel.

Step 2: Choosing the Right AI Model

Once installation is done, open the ModelHQ application, and then you will be prompted to add a setup method. The setup guide is provided after buying the application.

After this, you will land in the main menu. Now, click on the Chat button.

You’ll be prompted to select an AI model. If you’re unsure which model to choose, you can click on “choose for me,” and the application will select a suitable model based on your needs. Model HQ comes up with 100+ models.

Available Model Options:

Small Model:
~1– 3 billion parameters:- Fastest response time, suitable for basic chat.
Medium Model:
~7– 8 billion parameters:- Balanced performance, ideal for chat, data analysis, and standard RAG tasks.
Large Model:
~9 – up to 32 billion parameters:- Most powerful chat, RAG, and best for advanced and complex analytical workloads.

By the way, Model HQ will pick a smart default based on your system and use case.

The size of the model you choose can significantly impact both speed and output quality. Smaller models are faster but may provide less detailed responses. Follow this simple rule:

Step 3. Downloading Models

For demonstration purposes, we are selecting the Small Model.

If no models have been downloaded previously (e.g., in the No Setup, Fast Setup, or Full Setup paths), the selected model will begin downloading automatically.

This process typically takes 2–7 minutes, depending on the model you selected and your internet speed.

This is only a one-time internet requirement; once the models are downloaded, you don’t need internet anymore.

Step 4: Start Chatting

Once you’ve selected a model, you can start a chat by typing in your questions. For example, you might ask a simple question like, “What are the top sites to see in Paris?” The model will generate a response based on its training data.

Customizing Your Chat Experience

Model HQ allows you to customize your chat experience further. You can adjust settings such as the maximum output length and the randomness of the responses (known as temperature). By default, the app is set to generate up to 1,000 tokens, which is usually sufficient for smaller models. However, even if you’re using larger models, be cautious about increasing this limit, as it can consume more memory and take longer to generate responses. So, in short, you can adjust generation settings:

Max Tokens: How long should the response be?
Temperature: Should the answer be creative or precise?
Stop/Restart: Hit ❌ to stop a long generation anytime.

Step 5: Integrating Sources for Enhanced Responses

One of the standout features of Model HQ is its ability to integrate sources, such as documents and images, into your chat. To do this, simply click on the “source” button and upload a file, such as a PDF or Word document.

Example: Using a Document as a Source

For instance, if you upload an executive employment agreement, you can ask specific questions about the clauses within the document. The model will reference the uploaded document to provide accurate answers. This feature is invaluable for fact-checking and ensuring that you have the right information at your fingertips.

Chatting with Images

Model HQ also allows you to chat with images. By uploading an image, the application can analyze the content and answer questions based on what it sees. This capability opens up a world of possibilities for multimedia processing, all done locally on your machine without any additional costs.

Step 6: Saving and Downloading Results

After you’ve finished your session, you can save the chat results for future reference. This is particularly useful if you need to compile information for reports or presentations. Simply download the results, and you’ll have everything you need at your fingertips.

Step 7: Exploring Advanced Features

As you become more comfortable with Model HQ, you can explore its advanced features. For example, you can experiment with different models to see how they perform with various types of queries. You can also adjust the generation settings to fine-tune the responses based on your specific needs.

If you’re a visual learner, then watch this YouTube walkthrough:

Future Updates and Community Engagement

Stay engaged with the Model HQ community by following their updates and tutorials on platforms like YouTube. The Model HQ YouTube playlist offers valuable insights and tips to help you maximize your experience with the application.

Join the LLMWare’s Official Discord Server to interact with LLMWare’s great community of users and if you have any questions or feedback.

Why This Matters

Most AI apps require you to upload data to a cloud server. That’s slow, often expensive, and puts your privacy at risk.

With Model HQ, everything runs on your own machine with:

✅ No internet needed
✅ No Coding Required
✅ No API keys or credits
✅ No data leaves your PC
✅ Zero cost per query

It’s your personal AI lab, fully private and offline.

Conclusion: Get Started with Model HQ Today!

Creating a chatbot that runs locally without coding and an internet connection has never been easier. With Model HQ, you have access to a powerful AI tool that can enhance your productivity and streamline your workflow.

Ready to experience the future of AI? Visit the LLMWare website to learn more about Model HQ and its features. Don’t forget to sign up for the 90-day free trial for developers here and explore the application firsthand. When you’re ready to make the leap, you can purchase Model HQ directly here.

Unlock the full potential of AI on your PC or laptop with Model HQ today, and take the first step towards creating your very own local chatbot!

Here's how I created a Real-Time Discord Badge for Github Readme 🌠

Rohan Sharma — Tue, 01 Jul 2025 03:30:03 +0000

Hello all, I'm back with another project. This time, I built a Real-Time Discord badge that shows the total member count.

In this blog, I will share with you:

Why did I build this?
Why add a dynamic Discord badge to your GitHub Readme?
A step-by-step guide to adding this badge to your GitHub README, including how to customize it.
How I handled real-time Discord data, added Redis caching, managed rate limits, and made it fast.

So, let's start. 3... 2... 1... 🌱

Why did I build this?

I want to tell you a super short story for this. The company for which I'm working wanted me to add a dynamic Discord badge to their GitHub README that shows the total member count.

I tried searching on the web. After a lot of searching, I found that Discord already provides a "Server Widget JSON API". For this, you have to go to your Discord server settings > engagement, and then turn on the widget, and you will be able to find the API link and the Server ID.

You can create a badge using this Server ID as shown below:

[![demo](https://img.shields.io/discord/YOUR_SERVER_ID?logo=discord)](https://discord.gg/INVITE_CODE)

But the thing is, it will only show the online members count and not all the members.

I tried to search a lot about "how to show all members' count", but I wasn't able to find any.

And thus, I decided to create one. It was super easy. When I built it for my company, I realized there may be more people who want this badge as well, so I made it public for the community.

I don't know if such badges are already there in the market or not. I tried to find a lot, and the disappointment made me build it. If you know any such badges or methods to show dynamic Discord badges that update in real-time, then please let me know in the comment section.

Why add `Discord Live Members Count Badge` to your GitHub Readme?

Many open-source projects and communities wanted to showcase their Discord server growth on their GitHub READMEs because:

The bigger the community, the more trust it builds. Thus, showing your total Discord members count will not only market your product, but also build trust in future users.
Real-time metrics make your README dynamic. It gives a sense that the project is active and maintained.
Attracts contributors and collaborators. A growing community signals engagement, which can draw in more developers.
Helps community managers track growth. Badges provide a quick glance at server stats without needing to log into Discord.
Encourages more users to join. Seeing a badge with large numbers can trigger FOMO and boost Discord join rates.
Improves project credibility. Just like stars and forks, community size becomes a social proof metric.
Easier comparison between similar projects. Potential users can quickly evaluate community support through visible numbers.

And the most important point, "SNEAK-PEEK YOUR RIVALS OR ENEMY, OR FRIEND DISCORD COMMUNITY MEMBERS". I don't know about you, but I do it. All you need is their Server ID. Keep reading the blog, and I will tell you how to do this. (I'm not promoting any such activities. It's bad. Anyway, I don't care. 😂)

Step-by-Step Guide: Adding `Discord Live Members Count Badge` to Your GitHub README

Let's get your Discord badge up and running in less than 5 minutes!

Step 1: Add the `Live Count Bot` to Your Server

First, you need to invite my bot to your Discord server:

🤖 Click here to add the bot

The bot needs minimal permissions:

View Channels (to access your server)
Manage Channels (for member counting)

Step 2: Enable Server Widget

This is crucial - without this step, your badges won't work!

Right-click your server name → Server Settings
Navigate to Engagement → Server Widget
Toggle ON the "Enable Server Widget" option
Copy your Server ID (you'll need this!)

Still facing difficulty? Follow the Documentation here

What if you're not a core member of the Discord server? The above option is present only for the server owner, admins, and moderators (sometimes). But if you're none of them and still want to add this badge? Remember, I told you above the "Sneak-Peek" thing? We will apply it here.

If you're not a core member and still want to add this badge or want to sneak peek, then follow the steps below:

Open your Users Settings
Navigate to Advanced
Toggle ON the "Developer Mode" option
Now, right-click on any server and you will get an option to Copy Server ID

NOTE: The Live Members Count must be present in that server.

Step 3. Customize your Badge

Let's make it fast and as simple as possible.

Copy this template, add your Server ID and Invite Link(optional, but important) in the corresponding places, and paste it in your GitHub Readme.

[![discord members](https://discord-live-members-count-badge.vercel.app/api/discord-members?guildId=YOUR_SERVER_ID_HERE)](https://discord.gg/YOUR_NEVER_EXPIRY_INVITE_CODE_HERE)

It will show the total Discord member counts (including the bots).

I have made multiple endpoints, check it out here:

You can check the endpoints using this link:

Discord Members:

  https://discord-live-members-count-badge.vercel.app/api/discord-members?guildId=YOUR_SERVER_ID_HERE

2. Discord Bots:

  https://discord-live-members-count-badge.vercel.app/api/discord-bots?guildId=YOUR_SERVER_ID_HERE

3. Discord Total:

  https://discord-live-members-count-badge.vercel.app/api/discord-total?guildId=YOUR_SERVER_ID_HERE

But, do you like to customize it more??
Well, I have this. I have included three extra parameters to make it more customizable for you.

color (optional) - Hex color without # (default: 7289DA)
label (optional) - Custom text label (default: varies by endpoint)
scale (optional) - Size multiplier from 0.5 to 10.0 (default: 1)

You can use them as:
Badge Code:

[![discord members](https://discord-live-members-count-badge.vercel.app/api/discord-members?guildId=YOUR_SERVER_ID&color=27ae60&label=Users&scale=2)](https://discord.gg/your-invite)

Endpoint:

https://discord-live-members-count-badge.vercel.app/api/discord-members?guildId=YOUR_SERVER_ID&color=27ae60&label=Users&scale=2

Output:

Same for other endpoints. Btw, pink is my favorite color. I don't know why I created a green badge. Maybe the devil made me do it.

There's a possibility that you might get frustrated because you have to change the color and scale multiple times to get your best. Each time, you have to wait for the page to reload or hit enter.

To become your HERO again, I built the website too.

Discord Badge

Add beautiful, real-time Discord member count badges to your GitHub README

discord-live-members-count-badge.vercel.app

The interface is simple. But there are two things to be noticed:

1. Badge Generator

This is simple, add your Server ID and Invite Link. Click on Generate, and your badges will be generated. Copy and paste it directly into the readme.

2. Interactive Playground

Don't want to manually customize badges? I built an interactive playground where you can:

🎨 Pick colors from presets or use custom hex codes
📝 Edit labels with live preview
📏 Adjust scaling with a visual slider
📋 Copy ready-to-use markdown code

🚀 Try the Playground

How did I build it?

In this section, I will try to explain how I built this web application.

Step 1. Creating the Discord Bot

Go to Discord Developer Portal
Create a new application
Go to the Bot section
Create a bot and copy the token
Invite the bot to your server with these permissions:
- View Channels
- Manage Channels

In Privileged Gateway Intents, Presence Intent and Server Members Intent must be enabled.

Bot Permissions
For this case, the bot needs minimal permissions:

View Channels (1024)
Manage Channels (16)

Total permission integer: 1040

Step 2. Routes and API

`discord-members` API

It fetches the approximate member count using Discord's /guilds/{guildId}?with_counts=true endpoint.

const r = await axios.get(`https://discord.com/api/v10/guilds/${guildId}?with_counts=true`, {
  headers: { Authorization: `Bot ${process.env.DISCORD_BOT_TOKEN}` },
});

*Caching * is not implemented in this route due to the approximate and fast nature of the API call.

`discord-bots` API

It counts bots in a guild using the fetchAllMembers() utility.

const members = await fetchAllMembers(guildId);
const botCount = members.filter((m) => m.user.bot).length;

Key Points:

Calls Discord's /guilds/{guildId}/members endpoint (paginated).
Requires member intent (Privileged Intent must be enabled).
Filters bot users using m.user.bot.
Uses caching to reduce repeated heavy calls. (in utils)

`discord-total` API

It combines both bot and human user counts.

const members = await fetchAllMembers(guildId);
const botCount = members.filter((m) => m.user.bot).length;
const humanCount = members.length - botCount;

Key Points:

Same logic and fetching as discord-bots.
Shows combined info like 22 users, 5 bots.

`fetchAllMembers` Utility

Paginate through all members of a guild using Discord's API.

while (keepFetching) {
  const res = await axios.get(`https://discord.com/api/v10/guilds/${guildId}/members`, {
    headers: { Authorization: `Bot ${DISCORD_BOT_TOKEN}` },
    params: { limit: 1000, after },
  });
  ...
}

Caching:

Tries Redis first using key guild:{guildId}:members.

  if (redis) {
    try {
      const cached = await redis.get(cacheKey);
      if (cached) {
        console.log(`[Cache] HIT for ${guildId}`);
        return JSON.parse(cached);
      } else {
        console.log(`[Cache] MISS for ${guildId}`);
      }
    } catch (err) {
      console.warn(`[Cache] Redis error on GET: ${err.message}`);
    }
  }

On cache MISS, fetches from Discord and caches the result.
TTL is controlled via CACHE_TTL environment variable (default 300 seconds).

Rate Limiting Handling:

If API responds with 429, waits for retry_after seconds, and retries.
Adds setTimeout between requests to avoid hitting limits.

if (err.response?.status === 429) {
  const retryAfter = err.response.data?.retry_after || 1;
  await new Promise((r) => setTimeout(r, retryAfter * 1000));
  continue;
}

Badge Generation

All routes use the badge-maker package:

let svg = makeBadge({
  label,
  message,
  color,
  style: 'flat',
  logoBase64: `data:image/svg+xml;base64,${discordLogoBase64}`,
});

Scaling: Optional scale param adjusts badge size.

if (scale !== 1) {
  svg = svg
    .replace(/<svg([^>]+?)width="(\d+)" height="(\d+)"/, ...)
    .replace(/<svg[^>]*>/, `$1<g transform="scale(${scale})">`)
    .replace(/<\/svg>/, '</g></svg>');
}

Error Handling: If any call fails, a red "error" badge is returned.

Quick Summary

discord-members = fast estimate, no intents.
discord-bots & discord-total = precise, uses member list and cache.
fetchAllMembers handles paging, rate limits, and caching.

The setup supports scaling, CDN caching, and proper Discord rate limit compliance.

Step 3. Create UI and Deploy.

You can use any AI tool for creating the UI. I used V0 by Vercel. Also, for deploying my application, I used Vercel.

See it in Action

Check out the GitHub repository for the Source Code (liked this project? Star it 🌠):

RS-labhub / Discord-Live-Members-Count-Badge

Add beautiful, real-time Discord member count badges to your GitHub README

🎯 Discord Live Members Count Badge

Add beautiful, real-time Discord member count badges to your GitHub README

✨ Features

🔄 Real-time Updates - Live member count with smart caching (5-minute intervals)
👥 Multiple Badge Types - Total members, human-only, or bot-only counts
🛡️ Safe & Secure - Uses Discord API's with_counts=true for public access
⚡ Serverless Ready - Deploy to Vercel, Railway, Render, or any platform
🎨 Fully Customizable - Custom colors, labels, and scaling options
📱 Mobile Responsive - Optimized playground interface for all devices
📦 Zero Config - Just add your bot and start using

🎬 Project Showcase

Preview	Description
	🎬 YouTube Demo Click the image to watch the full demo.
	📝 Blog Post Read the blog for in-depth explanation.

🚀 Quick Start

1. Add Bot to Your Server

First, invite our bot to your Discord server:

🤖 Add Bot to Server

2. Enable Server Widget

Go to…

View on GitHub

Wait, wait, wait! Did you just ask for a Video Explanation? I have it for you already. Check it out here:

[ ] PROMOTION:

For the default badges on the website and the readme, I have used LLMWare's Discord Server with their consent. If you don't know, llmware just launched "Model HQ: Your Private AI Companion". The interesting part is that it runs locally and without internet.

Want to know more about it? Read it here

Rohan Sharma for LLMWare

Jun 27 '25

How to Run AI Models Privately on Your AI PC with Model HQ; No Cloud, No Code

#showdev #ai #security #nocode

Comments 17

5 min read

Conclusion

In short, try this once and let me know your feedback. I don't usually say it, but save this blog for the future and star the GitHub Repository.

All links in one place:

Discord Live Members Count Website
Documentation
GitHub Repository (star it 🌠)
Video Explanation (like and subscribe)

If you want me to RAISE A PR for this badge on your GitHub repository, then let me know in the comment section.

Also, in case you want to know more about me, here's my Portfolio (and yeah, try to find out the secret page, it's still waiting for you.)

Thanks for reading till here. You're awesomeeeeeeeeeee. Here's a hug from me 🫂. Keep growing. You're the best. 🫀

How to Run AI Models Privately on Your AI PC with Model HQ; No Cloud, No Code

Rohan Sharma — Fri, 27 Jun 2025 04:20:58 +0000

In an era where efficiency and data privacy are paramount, Model HQ by LLMWare emerges as a game-changer for professionals and enthusiasts alike. Built by LLMWare, Model HQ is a groundbreaking desktop application that transforms your own PC or laptop into a fully private, high-performance AI workstation.

Most AI tools rely on the cloud. Model HQ doesn’t.

No more cloud latency. No more vendor lock-in. Just 100+ cutting-edge AI models, blazing fast document search, and natural language tools; all running locally on your machine.

What is Model HQ?

Model HQ is a powerful, no-code desktop application that enables users to run enterprise-grade AI workflows locally, securely, and at scale, right from their own PC or laptop. Designed for simplicity and performance, it provides point-and-click access to 100+ state-of-the-art AI models, ranging from 1B to 32B parameters, with built-in optimization for AI PCs and Intel hardware. Whether you’re building AI applications, analyzing documents, or querying data, Model HQ automatically adapts to your device’s specs to ensure fast, efficient inferencing, even for large models that traditionally struggle on standard formats.

What truly sets Model HQ apart is its privacy-first, offline capability. Once models are downloaded, they can be used without Wi-Fi, keeping your data and sensitive information 100% on-device. This makes it the fastest and most secure way to explore and deploy powerful AI tools without depending on the cloud or external APIs. From developers and researchers to enterprise teams, Model HQ delivers a seamless, cost-effective, and private AI experience; all in one sleek, local platform.

What Model HQ can do?

1. Chat:
The Chat feature allows users a fast way to start experimenting with chat models of various sizes, from Small (1–3 billion parameters), Medium (7–8 billion parameters) to Large (9 and above, up to 32 billion parameters).

Small Model:

~1–3 billion parameters — Fastest response time, suitable for basic chat.
Medium Model:

~7–8 billion parameters — Balanced performance, ideal for chat, data analysis and standard RAG tasks.
Large Model:

~9 up to 32 billion parameters — Most powerful chat, RAG, and best for advanced and complex analytical workloads.

Watch Chat in Action

2. Agents
Agents in Model HQ are pre-configured or custom-built workflows that automate complex tasks using local AI models. They allow users to process files, extract insights, or perform multi-step operations; all with point-and-click simplicity and no coding required.

Users can build new agents from scratch, load existing ones (either from built-in templates or previously created workflows), and manage them through a simple dropdown interface. From editing or deleting agents to running batch operations on multiple documents, the Agent system provides a flexible way to scale private, on-device AI workflows. Pre-created agents include powerful tools like Contract Analyzer, Customer Support Bot, Financial Data Extractor, Image Tagger, and more — each designed to handle specific tasks efficiently.

Watch Agents in Action

3. Bots
The Bots feature allows users to create their own custom Chat and RAG bots seamlessly for either the AI PC/edge device use case (Fast Start Chatbot and Model HQ Biz Bot) or via API deployment (Model HQ API Server Biz Bot).

Watch Bots in Action

4. RAG
RAG combines retrieval-based techniques with generative AI to allow models to answer questions more accurately by retrieving relevant information from external sources or documents. With RAG in Model HQ, you can create knowledge bases that you can query in the chat section or via a custom bot by uploading documents. The RAG section is used only to create the knowledge base.

Watch Rag in Action

5. Models
The Models section allows you to explore, manage, and test models within Model HQ. You can discover new models, manage downloaded models, review inference history, and run benchmark tests; all from a single interface.

And this all can be done, while keeping your data private, your workflows offline, and your AI performance fully optimized for your device — no internet, no cloud, and no compromise. With its powerful features and user-friendly interface, Model HQ empowers you to leverage AI technology without compromising on security. Experience the future of AI today and transform the way you work!

System Requirements

Experience Model HQ Risk-Free

We understand that trying new software can be a leap of faith. That’s why we’re offering a 90-day free trial for developers. Experience the full capabilities of Model HQ without any commitment. Sign up for the trial here and discover how it can transform your workflow.

A Powerful Collaboration with Intel

LLMWare.ai has partnered with Intel to optimize Model HQ for peak performance on your devices. This collaboration ensures that you receive a reliable and efficient AI experience, making your tasks smoother and more productive. Learn more about this exciting partnership here.

Read the Intel Solution Brief here:

Local AI—No Code, More Secure with AI PCs and the Private Cloud

Bring secure, no-code GenAI to your enterprise with Intel® AI PCs and LLMWare’s Model HQ—run agents and RAG queries locally without exposing data or incurring cloud costs. In this brief, learn how to scale private AI simply and affordably.

intel.com

Take the Next Step Towards AI Empowerment

Don’t miss the chance to elevate your productivity with Model HQ. Whether you’re a business professional, a developer, or a student, this application is designed to meet your needs and exceed your expectations.

Purchase Model HQ Today!

Ready to unlock the full potential of AI on your PC or laptop? Buy Model HQ now by clicking here and take the first step towards a smarter, more efficient future.

Learn More About Model HQ

For additional information about Model HQ, including detailed features and user guides, visit our website. Don’t forget to check out our introductory video and explore our YouTube playlist for tutorials and tips.

Join the LLMWare’s official Discord Server to interact with LLMWare's great community of users and if you have any questions or feedback.

Conclusion

Model HQ isn’t just another AI app, it’s a complete, offline-first platform built for speed, privacy, and control. Whether you’re chatting with LLMs, building agents, analyzing documents, or deploying custom bots, everything runs securely on your own PC or laptop. With support for models up to 32B parameters, RAG-enabled document search, natural language SQL, and no-code workflows, Model HQ brings enterprise-grade AI directly to your desktop, no cloud required.

As the world moves toward AI-powered productivity, Model HQ ensures you’re ahead of the curve with a faster, safer, and smarter way to work.

Creating a Chatbot from Scratch and Vibe Coding the UI💃

Rohan Sharma — Sat, 21 Jun 2025 08:27:35 +0000

Hey all,

I hope you remember me. (Yes?? LMK in the comment section.)

In this blog, I will discuss Radhika: Adaptive Reasoning & Intelligence Assistant. It provides specialized assistance across six distinct modes: General, Productivity, Wellness, Learning, Creative, and BFF.

Radhika

Radhika is a versatile AI chatbot designed to assist with a wide range of tasks, from answering questions to providing recommendations and engaging in casual conversation.

radhika-sharma.vercel.app

(try it out, give feedback and suggestions, request changes)

🛠️ Tech Stack

Frontend

Framework: Next.js 14 with App Router and React 18
Styling: Tailwind CSS with custom design system
Components: shadcn/ui component library
Icons: Lucide React icon library
3D Graphics: Three.js for particle visualizations
Animations: CSS transitions and keyframe animations

AI & Backend

AI Integration: Vercel AI SDK for unified LLM access
Providers: Groq, Google Gemini, OpenAI, Claude
Speech: WebKit Speech Recognition and Synthesis APIs
Storage: Browser localStorage for chat persistence and settings
API: Next.js API routes for secure LLM communication

Development

Language: TypeScript for type safety
Build: Next.js build system with optimizations
Deployment: Vercel-ready with environment variable support
Performance: Optimized bundle splitting and lazy loading

🚀 Implementing Main Logic

This section breaks down how the app/api/chat/route.ts endpoint processes requests, selects models, applies system prompts, and streams responses using different AI providers.

1. Parse Request

The request handler begins by parsing the JSON body from the incoming POST request:

const body = await req.json();
const { messages, mode = "general", provider = "groq", apiKey } = body;

messages: The conversation history sent by the client.
mode: Determines which system prompt to use (e.g., bff, learning, etc.).
provider: Specifies the AI backend to use (groq, openai, claude, gemini).
apiKey: Required for OpenAI and Claude if a user key is needed.

The code also validates whether the messages array exists and is non-empty.

2. Assign System Prompt

Based on the selected mode, a system prompt is selected to guide the assistant's personality and purpose:

const systemPrompt = SYSTEM_PROMPTS[mode] || SYSTEM_PROMPTS.general;

Examples of modes include:

productivity
bff
creative
wellness

3. Route to the Correct Provider

The provider field determines which AI model backend to use:

Gemini (google): Uses Google's Gemini 2.0 model.
OpenAI: Uses GPT models (like gpt-4o, gpt-3.5-turbo).
Claude: Uses Anthropic models (like claude-3-sonnet).
Groq: Defaults to models like llama-3 and qwen.

Each provider has custom logic to instantiate the model, handle errors, and stream the response using:

await streamText({...})

4. Model Selection (Groq Only)

If the provider is groq, model selection is dynamic. It analyzes the last message to determine the type of task:

if (lastMessage.includes("analyze") || lastMessage.includes("plan")) {
  modelType = "reasoning";
} else if (lastMessage.includes("creative") || lastMessage.includes("design")) {
  modelType = "creative";
} else {
  modelType = "fast";
}

RADHIKA automatically selects the best model based on your query complexity:

// Determine which model to use based on conversation context
let modelType = "fast"; // llama-3.1-8b-instant for quick responses

// Use reasoning model for complex analytical tasks
if (query.includes("analyze", "compare", "plan", "strategy", "decision", "problem")) {
  modelType = "reasoning"; // llama-3.3-70b-versatile
}

// Use creative model for artistic and innovative tasks
if (query.includes("creative", "brainstorm", "idea", "write", "design", "story")) {
  modelType = "creative"; // qwen/qwen3-32b
}

Model Configuration

Customize model selection in the API route:

const MODELS = {
  groq: {
    fast: "llama-3.1-8b-instant",
    reasoning: "llama-3.3-70b-versatile", 
    creative: "qwen/qwen3-32b"
  },
  gemini: { default: "gemini-2.0-flash" },
  openai: { default: "gpt-4o" },
  claude: { default: "claude-3-5-sonnet-20241022" }
}

Then the appropriate model (reasoning, creative, or fast) is selected and used for the response.

📄 Multi-Provider Flow

This approach allows a single API route to serve multiple model providers and assistant personalities while maintaining clean, scalable logic.

If you're interested in knowing about the other logics like voice recognition and speech synthesis, light/dark mode, etc,. then please go over the github repo:

RS-labhub / Radhika

Radhika is a multi-model AI assistant built for your mood and friendship 💞

Radhika

Try now: https://radhika-sharma.vercel.app

Detailed Explanation

Preview	Description
	Blog Post Read the blog for in-depth explanation.
	YouTube Demo Coming soon.

Features

6 Chat Modes: General, Productivity, Wellness, Learning, Creative, BFF
Multi-Provider LLM: Groq, Gemini, OpenAI, Claude
Image Generation: Pollinations, DALL·E 3, Hugging Face, Free alternatives
Voice: Speech-to-text input & text-to-speech output
Auth & Persistence: Appwrite auth with chat history & favorites
UI: Light/dark themes, modern & pixel UI styles

Quick Start

git clone https://github.com/RS-labhub/radhika.git
cd radhika
bun install   # or npm install
bun run dev   # or npm run dev

Open: http://localhost:3000

License

MIT License - see LICENSE

Built with ❤️ by Rohan Sharma

⭐ Star • 🐛 Issues • 🗣️…

View on GitHub

Vibe Coding the UI

When you have successfully implemented the main logic of your application, use the AI tools like v0, lovable, or bolt to create an interface according to your "thoughts".

I used v0 and ChatGPT. Prompting... Prompting... and never-ending prompting... Check out the video below to see a simple, short explanation of this project with features. However, you still have live access to it!

If you like it, then please star the repo 🌠 and follow me on GH.

Key Highlights

🤖 Multi-Modal AI - Six specialized assistant personalities in one app
⚡ Multi-Provider Support - Groq, Gemini, OpenAI, and Claude integration
🎤 Advanced Voice - Speech-to-text input and text-to-speech output
🎨 Dynamic 3D Visuals - Interactive particle system with mode-based colors
💾 Smart Persistence - Automatic chat history saving per mode
🚀 Quick Actions - One-click access to common tasks per mode
📊 Real-time Analytics - Live usage statistics and AI activity monitoring
🌙 Beautiful UI - Responsive design with dark/light themes

Modes

Productivity: Task planning, project management, time optimization
Wellness: Health guidance, fitness routines, mental well-being support
Learning: Educational assistance, study plans, skill development
Creative: Brainstorming, content creation, artistic inspiration
General: Problem-solving, decision-making, everyday conversations
BFF: Emotional support, casual chats, GenZ-friendly interactions

Perfect for users who need a versatile AI assistant that adapts to different contexts, maintains conversation history across specialized domains, and provides an engaging visual experience with advanced voice capabilities.

Conclusion

Radhika is a sophisticated AI-powered assistant built with Next.js and powered by multiple LLM providers including Groq, Gemini, OpenAI, and Claude. RADHIKA adapts to different modes of interaction, providing specialized assistance for productivity, wellness, learning, creative tasks, and even acts as your GenZ bestie!

I personally suggest you try the "BFF" mode. You will like it for sure.

Once again, here are the links you don't want to miss out:

Live Demo: https://radhika-sharma.vercel.app/ (added modern/pixel UI options)
Github Repo: https://github.com/RS-labhub/Radhika (Give it a star 🌠)
Youtube Demo: https://www.youtube.com/watch?v=2FW6IJeOkzI

Thank you for reading. You're wonderful. And I mean it. Ba-bye, see you in the next blog. (and PLEASE SPAM THE COMMENT SECTION AS ALWAYS)

Find My Portfolio’s Secret Page; If You Can 🤫

Rohan Sharma — Fri, 13 Jun 2025 11:15:03 +0000

Did you miss me? I guess, yeah, you did. Sorry for that. I was so busy with my DevRel work at llmware. (not flaunting)

Btw, finally I'm able to complete my portfolio website. And this is what I wanted to share with my dev.to fam.

Thanks to AI tools that accelerated the process. Vibe coding is not that bad; it saves a lot of time.

So, let's start this super mini blog.

3... 2... 1... 🟢

Welcome to `RS PORTFOLIO` 👋

First of all, don't expect too much. It's just a normal portfolio. IS IT? Who knows.

Before discussing more about it, let me tell you the tech stack I have used:

NextJs (frontend and backend)
Radix UI (UI Enhancements)
FormSpree (for creating free unlimited forms)
Vercel (hosting)

And boom! These resources were enough to create a good-looking portfolio. Actually, my portfolio DP is the main reason for the clean UI. 🙂 (please say "yes")

Btw, it's responsive also. BUT I SUGGEST YOU TAKE A LOOK AT A BIGGER SCREEN. Mobile view is not that great. (Of course, I'm NOT going to work on this again)

Rohan Sharma - Software Developer, Professional Blog Writer and UI/UX Designer

Explore the portfolio of Rohan Sharma, featuring cutting-edge software projects, insightful blogs, and creative UI/UX work.

rohansrma.vercel.app

What makes my PORTFOLIO UNIQUE?

Simple and Professional UI?
Easy navigation?
Adding "not available for work" label in the experience page?
Printing Resume?
SECRET BUTTON?

Every portfolio is unique, and I can't judge them. (btw, I always judge them, an in-built feature)

My portfolio is also like other portfolio/. You can judge it as well. I tried to WRITE AS MANY FAKE THINGS AND SHOWCASE FAKE EXPERTISE AS POSSIBLE. What do you mean, everyone does it? 😂

I don't want to emphasize more on the SECRET BUTTON. Because it is very unprofessional. But those who know me personally must have expected something like this from me. So, I have to stand on their beliefs.

I, particularly, WANT YOU TO TAKE A LOOK AT MY PORTFOLIO, EXPLORE EVERY SECTION, AND GIVE ME FEEDBACK. (Feedback is important, you know. Doesn't matter whether I will implement them or not. Even if I'm implementing then, I can't say about the timespan. It may take decades.)

If you're a dark mode lover, I have added a dark mode functionality. TOTALLY AI DEPENDENT to implement this feature. I don't want to spend much time on color change.

I mostly used chatGPT for bug fixes (those F*** hydration errors) and v0 to amplify building and improved UI/.

The Mystery of SECRET BUTTON

Again, before starting, I want to say, "Please don't go for it. It's just a random off-topic, unprofessional button, and made for fun".

The secret button, as the name suggests, is very secret and so hidden. There's only one point to access that button. Yes, A SINGLE POINT.

It can be present anywhere and in any section. If you want to see it, then you have to FIND IT BY YOURSELF.

The secret page consists of nothing but my personal space, where I'm trying to change my relationship status from SINGLE TO BEING MINGLE. It's boring as there are long essays and boring paragraphs. NOT DEVELOPER FRIENDLY.

A little glance of the secret page:

What?? C'mon, I already told "A LITTLE".

Jokes Apart, Time to Conclude

Sorry for a short and promotional blog. I just wanted to share this with you guys.

Upcoming blog, going to be very cool. And you'll like it for sure!

Sharing again the Portfolio link: https://rohan-sharma-portfolio.vercel.app/

If you liked my portfolio, then comment.
If you found any bugs, then comment.
If you have any feedback, then comment.
If you want me to build an MCP (of your choice), then comment.

Thanks for reading and your support. You're the best. Keep loving me!

Access Granted!! Here's the recipe behind my AI DMS 🤞

Rohan Sharma — Sun, 04 May 2025 08:23:49 +0000

This is a submission for the Permit.io Authorization Challenge: AI Access Control

Hey there,
Welcome back! This is my 2nd entry for the Permit.io Authorization Challenge. (If you want to see the 1st one, here's the link: https://dev.to/rohan_sharma/access-control-handled-heres-how-i-built-my-dms-212)

This project is not different than the last one. It's still a document management system, but it now has more powerful features and configurations.//..

Welcome to Radhika's AI DocManager

Radhika's AI DocManager is still a DMS, but now it's come with the power of AI, new settings and configurations, modern UI (best dark mode), and powerful features. Test it on your local machine now!!! 👾

This project demonstrates how to implement fine-grained authorization for both users and AI agents in a Next.js application using Permit.io. It's a document management system where users can create, view, edit, and delete documents based on their roles and document ownership, and AI agents can assist with document management based on their assigned permissions.

Features

1️⃣ User Authorization

Role-Based Access Control (RBAC): Different roles (Admin, Editor, Viewer) have different permissions
Attribute-Based Access Control (ABAC): Document owners have special privileges
Fine-Grained Authorization: Using Permit.io to implement complex authorization rules

2️⃣ AI Authorization

AI Agent Roles: Define different AI agent roles with specific capabilities
Permission Levels: Configure what AI agents can access and modify
- No Access: AI agent cannot access the resource at all
- Read Only: AI agent can only read but not modify resources
- Suggest Only: AI can suggest changes that require human approval
- Full Access: AI has full access to read and modify resources
Approval Workflows: Require human approval for sensitive AI operations
Audit and Monitoring: Track all AI actions and approvals

3️⃣ Document Intelligence

Document Analysis: AI-powered analysis of document content and structure
Document Summarization: Generate concise summaries of documents
Content Improvement: AI suggestions for improving document content

Demo

Project Repo

Github Repo: https://github.com/RS-labhub/AI-DocManager

Documentation: https://rs-labhub.github.io/AI-DocManager/

My Journey

As said in the last blog, it was quite difficult to create a DMS or document management system, as there are so many brainstorming behind this.

Anyway, thanks to Permit.io for saving a lot of my time while creating policies. It's easy to use and enough to say goodbye to the old methods where we die while writing the code.

I used Permit.io to achieve these things:

Role-Based Access Control or RBAC
Attribute-Based Access Control or ABAC

Also, implemented the roles the AI should have. Here's both RBAC and ABAC are used. I used GROQ Cloud for fast LLM inference and OpenAI compatibility.

Overall, it was a fun experience building this project, and I enjoyed building it.

If you want to see the whole implementation of the Permit.io, please read the project Readme file!

Authorization for AI Applications with Permit.io

Authorization Model

User Authorization

The application implements the following user authorization model:

Admin: Can create, view, edit, and delete any document, and access the admin panel
Editor: Can create, view, and edit documents, but can only delete their own documents
Viewer: Can only view documents

Additionally, document owners have full control over their own documents regardless of their role.

AI Authorization

The application implements the following AI authorization model:

AI Agent Roles:
- Assistant: Helps with document organization and basic tasks
- Editor: Can edit and improve document content
- Analyzer: Analyzes document content and provides insights
AI Capabilities:
- read_documents: Ability to read document content
- suggest_edits: Ability to suggest edits to documents
- edit_documents: Ability to directly edit documents
- create_documents: Ability to create new documents
- delete_documents: Ability to delete documents
- analyze_content: Ability to analyze document content
- summarize_content: Ability to summarize documents
- translate_content: Ability to translate documents
- generate_content: Ability to generate new content
Permission Levels:
- NO_ACCESS: AI agent cannot access the resource at all
- READ_ONLY: AI agent can only read but not modify resources
- SUGGEST_ONLY: AI can suggest changes that require human approval
- FULL_ACCESS: AI has full access to read and modify resources

Implementation Details

AI Authorization Implementation

The application implements AI authorization through several key components:

1. AI Agent Management

The AIAgent interface defines the structure of AI agents:

export interface AIAgent {
  id: string;
  name: string;
  description: string;
  role: AIAgentRole;
  capabilities: AICapability[];
  createdBy: string;
  createdAt: string;
  updatedAt: string;
  isActive: boolean;
}

Administrators can manage AI agents through the admin panel, defining their roles and capabilities.

2. Permission Levels

The AIPermissionLevel enum defines the different levels of access that AI agents can have:

export enum AIPermissionLevel {
  NO_ACCESS = "no_access",
  READ_ONLY = "read_only",
  SUGGEST_ONLY = "suggest_only",
  FULL_ACCESS = "full_access",
}

3. AI Actions

The AIAction interface defines the structure of actions that AI agents can perform:

export interface AIAction {
  id: string;
  agentId: string;
  actionType: string;
  resourceType: string;
  resourceId: string;
  status: AIActionStatus;
  requestedAt: string;
  completedAt?: string;
  requestedBy: string;
  approvedBy?: string;
  rejectedBy?: string;
  metadata: Record<string, any>;
  result?: any;
}

4. Permission Checking

The checkAIPermission function checks if an AI agent has permission to perform an action:

export function checkAIPermission(
  agentId: string,
  action: string,
  resourceType: string,
  resourceId?: string
): {
  permitted: boolean;
  requiresApproval: boolean;
  permissionLevel: AIPermissionLevel;
} {
  // Implementation details...
}

5. Approval Workflow

The application implements an approval workflow for AI actions that require human oversight:

export async function requestAIAction(
  agentId: string,
  actionType: string,
  resourceType: string,
  resourceId: string,
  documentTitle: string,
  documentContent: string,
  metadata: Record<string, any>
): Promise<{ success: boolean; action?: AIAction; message?: string }> {
  // Implementation details...
}

export async function approveAIAction(
  actionId: string,
  userId: string
): Promise<{ success: boolean; action?: AIAction; message?: string }> {
  // Implementation details...
}

export async function rejectAIAction(
  actionId: string,
  userId: string,
  reason?: string
): Promise<{ success: boolean; action?: AIAction; message?: string }> {
  // Implementation details...
}

Integration with Permit.io

The application integrates with Permit.io through the permit.ts file, which provides functions for checking permissions:

import { Permit } from 'permitio';

// Initialize Permit SDK
const permit = new Permit({
  pdp: process.env.PERMIT_PDP_URL,
  token: process.env.PERMIT_SDK_TOKEN,
});

// Check if a user can perform an action on a resource
export async function checkPermission(
  userId: string,
  action: string,
  resourceType: string,
  resourceAttributes: Record<string, any> = {}
): Promise<boolean> {
  try {
    const permitted = await permit.check(userId, action, {
      type: resourceType,
      ...resourceAttributes,
    });
    return permitted;
  } catch (error) {
    console.error('Permission check failed:', error);
    return false;
  }
}

Conclusion

This project demonstrates how to implement fine-grained authorization for both users and AI agents in a Next.js application using Permit.io. By externalizing authorization, we can create more secure, maintainable, and flexible applications that can safely leverage AI capabilities while maintaining appropriate controls.

Please try to run it locally on your machine and let me know the feedback!

Thank you for taking your time to read this blog. I hope you enjoyed it. Your support means the world to me. Thank youuuuuuuuuuuuuuuuu! ❣️

Access Control? Handled. Here's How I Built My DMS 🌠

Rohan Sharma — Tue, 29 Apr 2025 19:08:04 +0000

This is a submission for the Permit.io Authorization Challenge: Permissions Redefined

What I Built

Hi there! 👋
Presenting to you "Radhika's DocManager": A secure Document Management System (or DMS) with fine-grained authorization powered by Permit.io.

This is the first version of Radhika's DocManager, which allows you to create, read, write, and delete documents based on their role and document ownership.

Features

Role-Based Access Control (RBAC): Different roles (Admin, Editor, Viewer) have different permissions
Attribute-Based Access Control (ABAC): Document owners have special privileges
Fine-Grained Authorization: Using Permit.io to implement complex authorization rules
Next.js App Router: Modern React application with server components and server actions
Responsive UI: Using Tailwind CSS and shadcn/ui components

Authorization Model

The application implements the following authorization model:

Admin: Can create, view, edit, and delete any document, and access the admin panel
Editor: Can create, view, and edit documents, but can also delete their own documents
Viewer: Can only view documents

Additionally, document owners have full control over their own documents regardless of their role.

Demo

Project Repo

https://github.com/RS-labhub/Document_Management_System

My Journey

Creating a DMS was a very hectic job, especially while writing the access control. Thanks to Permit, which makes it easier and serves as a super time saver.

The thing that focused more on this application is the "Use of Permit". This also proves how a simple application becomes so powerful by adding access controls.

Anyway, the project is open-source. If you want to contribute, you're warmly welcome.

Using Permit.io for Authorization

I used Permit to achieve two things:

Role-Based Access Control or RBAC
Attribute-Based Access Control or ABAC

In the RBAC policy, 3 roles are created: Admin, Editor, and Viewer. The properties/permissions of each role are mentioned in the image.

In the ABAC policy, access is determined by document attributes and user context.

If you want to see the whole implementation of the Permit, please read the project Readme file!

Conclusion

A huge thanks to @jennie_py for their contribution to this project!

This project demonstrates how to implement fine-grained authorization in a Next.js application using Permit.io. By externalizing authorization, we can create more secure, maintainable, and flexible applications.

Thank you for reading this so far! Your support means the world to us. ❣️

Top 10 Open-Source RAG Frameworks you need!! 🧌

Rohan Sharma — Wed, 12 Mar 2025 04:31:14 +0000

The capabilities of Large Language Models (LLMs) are enhanced by Retrieval-Augmented Generation (RAG). Thus, RAG comes up with a super powerful technique that distinguishes it from others.

RAG Frameworks are tools and libraries that help developers build AI models that can retrieve relevant information from external sources (like databases or documents) and generate better responses based on that information.

RAG and it's Flowchart 🎴

Imagine you have a big toy box filled with all your favorite toys. But sometimes, when you want to find your favorite teddy bear, it takes a long time because the toys are all mixed up.

Now, think of RAG (Retrieval-Augmented Generation) as a magical helper. This helper is really smart! When you ask, "Where is my teddy bear?", it quickly looks through the toy box, finds the teddy bear, and gives it to you right away.

In the same way, when you ask a computer a question, RAG helps it find the right information from a big book before giving you an answer. So instead of just guessing, it finds the best answer from the book and tells you! 😊

R A G = R e t r i e v a lB a se d S ys t e m + G e n er a t i v e M o d e l s

Flowchart

RAG OverSimplified

How RAG Frameworks Work ⚒️

Retrieve → Search for relevant documents using a vector database.
Augment → Feed those documents into the LLM as extra context.
Generate → The LLM generates an informed response using both retrieved data and its own training knowledge.

Example

🔹 Step 1: User Question
Example: "Who discovered gravity?"

🔹 Step 2: Retrieve Relevant Information
Searches a knowledge base (e.g., Wikipedia, company documents)
Finds: "Isaac Newton formulated the law of gravity in 1687."

🔹 Step 3: Augment & Generate Answer
The LLM takes the retrieved information + its own knowledge
Generates a complete, well-structured response

🔹 Step 4: Final Answer
Example: "Gravity was discovered by Isaac Newton in 1687."

I hope now you're somewhat clear with the Rag concept. Now, in this blog, we will be discussing the top 10 Open-Source RAG frameworks that will help you boost your project or enterprise.

Top 10 Open-Source RAG Frameworks you need!! 📃

Here's a curated list of some famous and widely used RAG frameworks, you might not want to miss:

1️⃣ LLMWare.ai

11K Github Stars, 1.8K Forks

LLMWare.ai- https://llmware.ai

LLMWare provides a unified framework for building LLM-based applications (e.g., RAG, Agents), using small, specialized models that can be deployed privately, integrated with enterprise knowledge sources safely and securely, and cost-effectively tuned and adapted for any business process.

Core Features

RAG support for enterprise-level AI apps.
LLM Orchestration – Connects multiple LLMs (OpenAI, Anthropic, Google, etc.).
Document Processing & Embeddings – Enables structured AI-driven search.
Vector Database Integration – Works with Pinecone, ChromaDB, Weaviate, etc.
Custom Fine-Tuning – Train models on private datasets.

🔹Use Cases

Chatbots & virtual assistants
AI-driven search and retrieval
Summarization & text analysis
Enterprise knowledge management
Financial Analysis

Why LLMWare.ai?

Faster AI development with pre-built tools
Scalable & flexible for enterprise applications
Open-source & extensible

llmware-ai / llmware

Unified framework for building enterprise RAG pipelines with small, specialized models

llmware

🧰🛠️ Unified framework for building knowledge-based local, private, secure LLM-based applications

llmware is optimized for AI PC and local laptop, edge and self-hosted deployment across a wide range of Windows, Mac and Linux platforms, with support for GGUF, OpenVINO, ONNXRuntime, ONNXRuntime-QNN (Qualcomm), WindowsLocalFoundry, and Pytorch, providing a high-level interface that makes it easy to leverage the right inferencing technology optimized for the target platform.

llmware has two main components:

Model catalog with 300+ models - models prepackaged in quantized, optimized formats, to leverage on device GPU and NPU capabilities, with support for major open source model families and 50+ llmware finetuned SLIM, Bling, Dragon and Industry-Bert models specialized for key tasks in enterprise process automation. Also supports leading cloud models from OpenAI, Anthropic and Google.
RAG Pipeline - integrated components for the full lifecycle of connecting knowledge sources to generative AI models with wide range of document parsing and…

View on GitHub

Star LLMWare on GitHub ⭐	LLMWare Discord Server 💬

2️⃣ LlamaIndex (Formerly GPT Index)

39.8K Github Stars, 5.7K Forks

LlamaIndex: https://www.llamaindex.ai

LlamaIndex (GPT Index) is a data framework for your LLM application. Building with LlamaIndex typically involves working with LlamaIndex core and a chosen set of integrations (or plugins).

Core Features

Indexing & Retrieval – Organizes data efficiently for fast lookups.
Modular Pipelines – Customizable components for RAG workflows.
Multiple Data Sources – Supports PDFs, SQL, APIs, and more.
Vector Store Integrations – Works with Pinecone, FAISS, ChromaDB.

🔹Use Cases

AI-powered search engines
Knowledge retrieval for chatbots
Code and document understanding

Why LlamaIndex?

Easy to integrate with OpenAI, LangChain, etc.
Highly flexible & modular for different AI tasks.
Supports structured & unstructured data.

run-llama / llama_index

LlamaIndex is the leading document agent and OCR platform

🗂️ LlamaIndex 🦙

LlamaIndex OSS (by LlamaIndex) is an open-source framework to build agentic applications. Parse is our enterprise platform for agentic OCR, parsing, extraction, indexing and more. You can use LlamaParse with this framework or on its own; see LlamaParse below for signup and product links.

📚 Documentation:

LlamaParse

LlamaIndex OSS

LlamaAgents

Building with LlamaIndex typically involves working with LlamaIndex core and a chosen set of integrations (or plugins). There are two ways to start building with LlamaIndex in Python:

Starter: llama-index. A starter Python package that includes core LlamaIndex as well as a selection of integrations.
Customized: llama-index-core. Install core LlamaIndex and add your chosen LlamaIndex integration packages on LlamaHub that are required for your application. There are over 300 LlamaIndex integration packages that work seamlessly with core, allowing you to build with your preferred LLM, embedding, and vector store providers.

The LlamaIndex…

View on GitHub

Star LlamaIndex on GitHub ⭐	LlamaIndex Discord Server 💬

3️⃣ Haystack (by deepset AI)

19.7K Github Stars, 2.1K Forks

Haystack: https://haystack.deepset.ai

Haystack is an end-to-end LLM framework that allows you to build applications powered by LLMs, Transformer models, vector search and more. Whether you want to perform retrieval-augmented generation (RAG), document search, question answering or answer generation, Haystack can orchestrate state-of-the-art embedding models and LLMs into pipelines to build end-to-end NLP applications and solve your use case.

Core Features

Retrieval & Augmentation – Combines document search with LLMs.
Hybrid Search – Uses BM25, Dense Vectors, and Neural Retrieval.
Pre-built Pipelines – Modular approach for rapid development.
Integration Support – Works with Elasticsearch, OpenSearch, FAISS.

🔹Use Cases

AI-powered document Q&A
Context-aware virtual assistants
Scalable enterprise search

Why Haystack?

Optimized for production RAG applications.
Supports various retrievers & LLMs for flexibility.
Strong enterprise adoption & community.

run-llama / llama_index

LlamaIndex is the leading document agent and OCR platform

🗂️ LlamaIndex 🦙

📚 Documentation:

LlamaParse

LlamaIndex OSS

LlamaAgents

Building with LlamaIndex typically involves working with LlamaIndex core and a chosen set of integrations (or plugins). There are two ways to start building with LlamaIndex in Python:

Starter: llama-index. A starter Python package that includes core LlamaIndex as well as a selection of integrations.
Customized: llama-index-core. Install core LlamaIndex and add your chosen LlamaIndex integration packages on LlamaHub that are required for your application. There are over 300 LlamaIndex integration packages that work seamlessly with core, allowing you to build with your preferred LLM, embedding, and vector store providers.

The LlamaIndex…

View on GitHub

Star Haystack on GitHub ⭐	Haystack Discord Server 💬

4️⃣ Jina AI

21.4K Github Stars, 2.2K Forks (jina-ai/serve)

Jina AI: https://jina.ai/

Jina AI is an open-source MLOps and AI framework designed for neural search, generative AI, and multimodal applications. It enables developers to build scalable AI-powered search systems, chatbots, and RAG (Retrieval-Augmented Generation) applications efficiently.

Core Features

Neural Search – Uses deep learning for document retrieval.
Multi-modal Data Support – Works with text, images, audio.
Vector Database Integration – Built-in support for Jina Embeddings.
Cloud & On-Premise Support – Easily deployable on Kubernetes.

🔹Use Cases

AI-powered semantic search
Multi-modal search applications
Video, image, and text retrieval

Why Jina AI?

Fast & scalable for AI-driven search.
Supports multiple LLMs & vector stores.
Well-suited for both startups & enterprises.

jina-ai / serve

☁️ Build multimodal AI applications with cloud-native stack

Jina-Serve

Jina-serve is a framework for building and deploying AI services that communicate via gRPC, HTTP and WebSockets. Scale your services from local development to production while focusing on your core logic.

Key Features

Native support for all major ML frameworks and data types
High-performance service design with scaling, streaming, and dynamic batching
LLM serving with streaming output
Built-in Docker integration and Executor Hub
One-click deployment to Jina AI Cloud
Enterprise-ready with Kubernetes and Docker Compose support

Comparison with FastAPI

Key advantages over FastAPI:

DocArray-based data handling with native gRPC support
Built-in containerization and service orchestration
Seamless scaling of microservices
One-command cloud deployment

Install

pip install jina

See guides for Apple Silicon and Windows.

Core Concepts

Three main layers:

Data: BaseDoc and DocList for input/output
Serving: Executors process Documents, Gateway connects services
Orchestration: Deployments serve Executors, Flows create pipelines

Build AI Services

Let's create a gRPC-based…

View on GitHub

Star Jina AI on GitHub ⭐	Jina AI Discord Server 💬

5️⃣ Cognita by truefoundry

3.9K Github Stars, 322 Forks

Cognita: https://cognita.truefoundry.com

Cognita addresses the challenges of deploying complex AI systems by offering a structured framework that balances customization with user-friendliness. Its modular design ensures that applications can evolve alongside technological advancements, providing long-term value and adaptability.

Core Features

Modular Architecture – Seven customizable components (data loaders, parsers, embedders, rerankers, vector databases, metadata store, query controllers).
Vector Database Support – Compatible with Qdrant, SingleStore, and other databases.
Customizability – Easily extend or swap components for different AI applications.
Scalability – Designed for enterprise use, supporting large datasets and real-time retrieval.
API-Driven – Seamless integration with existing AI pipelines.

🔹Use Cases

AI-powered Customer Support with real-time retrieval.
Enterprise Knowledge Management
Context-Aware AI Assistants

Why Cognita?

Open-source with modular design for custom RAG workflows.
Works with LangChain, LlamaIndex, and multiple vector stores.
Built for scalable and reliable AI solutions.

truefoundry / cognita

RAG (Retrieval Augmented Generation) Framework for building modular, open source applications for production by TrueFoundry

Cognita

Why use Cognita?

Langchain/LlamaIndex provide easy to use abstractions that can be used for quick experimentation and prototyping on jupyter notebooks. But, when things move to production, there are constraints like the components should be modular, easily scalable and extendable. This is where Cognita comes in action Cognita uses Langchain/Llamaindex under the hood and provides an organisation to your codebase, where each of the RAG component is modular, API driven and easily extendible. Cognita can be used easily in a local setup, at the same time, offers you a production ready environment along with no-code UI support. Cognita also supports incremental indexing by default.

You can try out Cognita at: https://cognita.truefoundry.com

🎉 What's new in Cognita

[September, 2024] Cognita now has AudioParser (https://github.com/fedirz/faster-whisper-server) and VideoParser (AudioParser + MultimodalParser).
[August, 2024] Cognita has now moved to using pydantic v2.
[July, 2024] Introducing model gateway a single file to…

View on GitHub

Star Cognita on GitHub ⭐	Cognita Slack Community 💬

6️⃣ RAGFlow by infiniflow

43.9K Github Stars, 3.9K Forks

RAGFlow: https://ragflow.io/

RAGFlow is an open-source Retrieval-Augmented Generation (RAG) engine developed by InfiniFlow, focusing on deep document understanding to enhance AI-driven question-answering systems.

Core Features

Deep Document Understanding: RAGFlow excels in processing complex, unstructured data formats, enabling accurate information extraction and retrieval.
Template-Based Chunking: It employs intelligent, explainable chunking methods with various templates to optimize data processing.
Integration with Infinity Database: RAGFlow seamlessly integrates with Infinity, an AI-native database optimized for dense and sparse vector searches, enhancing retrieval performance.
GraphRAG Support: The engine incorporates GraphRAG, enabling advanced retrieval-augmented generation capabilities.
Scalability: Designed to handle extensive datasets, RAGFlow is suitable for businesses of all sizes.

🔹Use Cases

Enterprise Knowledge Management
Legal Document Analysis
AI-Powered Customer Support
Medical Research
Financial Analysis

Why RAGFlow?

Deep Document Processing – Structures unstructured data for complex analysis.
Graph-Enhanced RAG – Uses graph-based retrieval for smarter responses.
Hybrid Search – Combines vector and keyword search for accuracy.
Enterprise Scalability – Handles large-scale AI search applications.

infiniflow / ragflow

RAGFlow is a leading open-source Retrieval-Augmented Generation (RAG) engine that fuses cutting-edge RAG with Agent capabilities to create a superior context layer for LLMs

Document | Roadmap | Twitter | Discord | Demo

📕 Table of Contents

💡 What is RAGFlow?
🎮 Demo
📌 Latest Updates
🌟 Key Features
🔎 System Architecture
🎬 Get Started
🔧 Configurations
🔧 Build a Docker image
🔨 Launch service from source for development
📚 Documentation
📜 Roadmap
🏄 Community
🙌 Contributing

💡 What is RAGFlow?

RAGFlow is a leading open-source Retrieval-Augmented Generation (RAG) engine that fuses cutting-edge RAG with Agent capabilities to create a superior context layer for LLMs. It offers a streamlined RAG workflow adaptable to enterprises of any scale. Powered by a converged context engine and pre-built agent templates, RAGFlow enables developers to transform complex data into high-fidelity, production-ready AI systems with exceptional efficiency and precision.

🎮 Demo

Try our demo at https://demo.ragflow.io.

🔥 Latest Updates

2025-12-26 Supports 'Memory' for AI agent.
2025-11-19 Supports Gemini 3 Pro.
2025-11-12 Supports data synchronization from Confluence…

View on GitHub

Star RAGFlow on GitHub ⭐	RAGFlow Discord Server 💬

7️⃣ txtAI by NeuML

10.5K Github Stars, 669 Forks

txtAI: https://neuml.github.io/txtai/

txtAI is an open-source AI-powered search engine and embeddings database, designed for semantic search, RAG, and document similarity.

Core Features

Embeddings Indexing – Stores and retrieves documents using vector-based search.
RAG Integration – Enhances LLM responses with retrieval-augmented generation.
Multi-Modal Support – Works with text, images, and audio embeddings.
Scalable & Lightweight – Runs on edge devices, local systems, and cloud.
APIs & Pipelines – Provides an API for text search, similarity, and question answering.
SQLite Backend – Uses SQLite-based vector storage for fast retrieval.

🔹Use Cases:

AI-Powered Semantic Search
Chatbot Augmentation
Content Recommendation
Automated Tagging & Classification

Why txtai?

Lightweight & Efficient – Runs on low-resource environments.
Versatile & Extendable – Works with any embeddings model.
Fast Retrieval – Optimized for local and cloud-scale deployments.

neuml / txtai

💡 All-in-one AI framework for semantic search, LLM orchestration and language model workflows

All-in-one AI framework

txtai is an all-in-one AI framework for semantic search, LLM orchestration and language model workflows.

The key component of txtai is an embeddings database, which is a union of vector indexes (sparse and dense), graph networks and relational databases.

This foundation enables vector search and/or serves as a powerful knowledge source for large language model (LLM) applications.

Build autonomous agents, retrieval augmented generation (RAG) processes, multi-model workflows and more.

Summary of txtai features:

🔎 Vector search with SQL, object storage, topic modeling, graph analysis and multimodal indexing
📄 Create embeddings for text, documents, audio, images and video
💡 Pipelines powered by language models that run LLM prompts, question-answering, labeling, transcription, translation, summarization and more
↪️️ Workflows to join pipelines together and aggregate business logic. txtai processes can be simple microservices or multi-model workflows.
🤖 Agents that intelligently connect embeddings, pipelines, workflows and other agents together to autonomously…

View on GitHub

Star txtAI on GitHub ⭐	txtAI Slack Community 💬

8️⃣ STORM by stanford-oval

23.2K Github Stars, 2K Forks

STORM: https://github.com/stanford-oval/storm

STORM is an AI-powered knowledge curation system developed by the Stanford Open Virtual Assistant Lab (OVAL). It automates the research process by generating comprehensive, citation-backed reports on various topics.

Core Features

Perspective-Guided Question Asking: STORM enhances the depth and breadth of information by generating questions from multiple perspectives, leading to more comprehensive research outcomes.
Simulated Conversations: The system simulates dialogues between a Wikipedia writer and a topic expert, grounded in internet sources, to refine its understanding and generate detailed reports.
Multi-Agent Collaboration: STORM employs a multi-agent system that simulates expert discussions, focusing on structured research and outline creation, and emphasizes proper citation and sourcing.

🔹Use Cases

Academic Research: Assists researchers in generating comprehensive literature reviews and summaries on specific topics.
Content Creation: Aids writers and journalists in producing well-researched articles with accurate citations.
Educational Tools: Serves as a resource for students and educators to quickly gather information on a wide range of subjects.

Why Choose STORM?

Automated In-Depth Research: STORM streamlines the process of gathering and synthesizing information, saving time and effort.
Comprehensive Reports: By considering multiple perspectives and simulating expert conversations, STORM delivers well-rounded and detailed reports.
Open-Source Accessibility: Being open-source, STORM allows for customization and integration into various workflows, making it a versatile tool for different users.

stanford-oval / storm

An LLM-powered knowledge curation system that researches a topic and generates a full-length report with citations.

STORM: Synthesis of Topic Outlines through Retrieval and Multi-perspective Question Asking

Latest News 🔥

[2025/01] We add litellm integration for language models and embedding models in knowledge-storm v1.1.0.
[2024/09] Co-STORM codebase is now released and integrated into knowledge-storm python package v1.0.0. Run pip install knowledge-storm --upgrade to check it out.
[2024/09] We introduce collaborative STORM (Co-STORM) to support human-AI collaborative knowledge curation! Co-STORM Paper has been accepted to EMNLP 2024 main conference.
[2024/07] You can now install our package with pip install knowledge-storm!
[2024/07] We add VectorRM to support grounding on user-provided documents, complementing existing support of search engines (YouRM, BingSearch). (check out #58)
[2024/07] We release demo light for developers a minimal user interface built with streamlit framework in Python, handy for local development and demo hosting (checkout #54)
[2024/06] We…

View on GitHub

Star STORM on GitHub ⭐

9️⃣ LLM-App by pathwaycom

22.5K Github Stars, 379 Forks

LLM-App: https://pathway.com/developers/templates/

LLM-App is an open-source framework developed by Pathway.com, designed to integrate Large Language Models (LLMs) into data processing workflows.

Core Features

Seamless LLM Integration: Allows for the incorporation of LLMs into various applications, enhancing data processing capabilities.
Real-Time Data Processing: Utilizes Pathway's real-time data processing engine to handle dynamic data streams efficiently.
Extensibility: Designed to be adaptable, enabling users to customize and extend functionalities based on specific requirements.

🔹Use Cases

Data Analysis
Natural Language Processing (NLP)
Chatbots and Virtual Assistants

Why Choose LLM-App?

Integration with Pathway's Engine: Combines the power of LLMs with Pathway's robust data processing engine for efficient real-time applications.
Open-Source Flexibility: Being open-source, it allows for community contributions and customization to fit diverse use cases.
Scalability: Designed to handle large-scale data processing tasks, making it suitable for enterprise applications.

pathwaycom / llm-app

Ready-to-run cloud templates for RAG, AI pipelines, and enterprise search with live data. 🐳Docker-friendly.⚡Always in sync with Sharepoint, Google Drive, S3, Kafka, PostgreSQL, real-time data APIs, and more.

Pathway AI Pipelines

Pathway's AI Pipelines allow you to quickly put in production AI applications that offer high-accuracy RAG and AI enterprise search at scale using the most up-to-date knowledge available in your data sources. It provides you ready-to-deploy LLM (Large Language Model) App Templates. You can test them on your own machine and deploy on-cloud (GCP, AWS, Azure, Render,...) or on-premises.

The apps connect and sync (all new data additions, deletions, updates) with data sources on your file system, Google Drive, Sharepoint, S3, Kafka, PostgreSQL, real-time data APIs. They come with no infrastructure dependencies that would need a separate setup. They include built-in data indexing enabling vector search, hybrid search, and full-text search - all done in-memory, with cache.

Application Templates

The application templates provided in this repo scale up to millions of pages of documents. Some of them are optimized for simplicity, some are optimized…

View on GitHub

Star LLM-App on GitHub ⭐	LLM-App Discord Server 💬

🔟 Neurite by satellitecomponent

1.4K Github Stars, 127 Forks

Neurite: https://neurite.network//

Neurite is an open-source project that offers a fractal graph-of-thought system, enabling rhizomatic mind-mapping for AI agents, web links, notes, and code.

Core Features

Fractal Graph-of-Thought: Implements a unique approach to knowledge representation using fractal structures.
Rhizomatic Mind-Mapping: Facilitates non-linear, interconnected mapping of ideas and information.
Integration Capabilities: Allows integration with AI agents, enhancing their knowledge management and retrieval processes.

🔹Use Cases

Knowledge Management
AI Research
Educational Tools

Why Choose Neurite?

Innovative Knowledge Representation: Offers a novel approach to organizing information, beneficial for complex data analysis.
Open-Source Accessibility: Allows users to customize and extend functionalities to suit specific needs.
Community Engagement: Encourages collaboration and sharing of ideas within the knowledge management community.

satellitecomponent / Neurite

Fractal Graph-of-Thought. Rhizomatic Mind-Mapping for Ai-Agents, Web-Links, Notes, and Code.

🌐 neurite.network 🌐

⚠️ Warning: Contains flashing lights and colors which may affect those with photosensitive epilepsy.

Check out our newly released series of demo videos!

🌱 This is an open-source project in active development.

Welcome to Neurite | Getting Started

`Introduction`

Bridging Fractals and Thought

💡 neurite.network unleashes a new dimension of digital interface...

...the fractal dimension.

🧩 Drawing from chaos theory and graph theory, Neurite unveils the hidden patterns and intricate connections that shape creative thinking.

For over two years we've been iterating out a virtually limitless workspace that blends the mesmerizing complexity of fractals with contemporary mind-mapping technique.

📢 Major Update: Neurite Desktop

`Why Fractals?`

The Mandelbrot Set is not just an aesthetic choice - fractal logic is ingrained into a countless number…

View on GitHub

Star Neurite on GitHub ⭐	Neurite Discord Server 💬

Bonus 🙂‍↕️: R2R by SciPhi-AI

5.4K Github Stars, 400 Forks

R2R: https://r2r-docs.sciphi.ai/introduction

R2R is an advanced AI retrieval system that implements agentic Retrieval-Augmented Generation (RAG) with a RESTful API, developed by SciPhi-AI.

Core Features

Agentic RAG System: Combines retrieval systems with generation capabilities to provide comprehensive responses.
RESTful API: Offers a standardized API for easy integration into various applications.
Advanced Retrieval Mechanisms: Utilizes sophisticated algorithms to fetch relevant information efficiently.

🔹Use Cases

Intelligent Search Engines
Content Generation
Research Assistance

Why Choose R2R?

Comprehensive AI Retrieval: Offers advanced retrieval capabilities, making it suitable for complex information retrieval tasks.
Easy Integration: The RESTful API design allows for seamless integration into existing systems.
Open-Source Community: Being open-source, it benefits from community contributions and continuous improvements.

SciPhi-AI / R2R

SoTA production-ready AI retrieval system. Agentic Retrieval-Augmented Generation (RAG) with a RESTful API.

The most advanced AI retrieval system

Agentic Retrieval-Augmented Generation (RAG) with a RESTful API.

Docs · Report Bug · Feature Request · Discord

About

R2R is an advanced AI retrieval system supporting Retrieval-Augmented Generation (RAG) with production-ready features. Built around a RESTful API, R2R offers multimodal content ingestion, hybrid search, knowledge graphs, and comprehensive document management.

R2R also includes a Deep Research API, a multi-step reasoning system that fetches relevant data from your knowledgebase and/or the internet to deliver richer, context-aware answers for complex queries.

Usage

# Basic search
results = client.retrieval.search(query="What is DeepSeek R1?")
# RAG with citations
response = client.retrieval.rag(query="What is DeepSeek R1?")

# Deep Research RAG Agent
response = client.retrieval.agent(
  message={"role":"user", "content": "What does deepseek r1

…

View on GitHub

Star R2R on GitHub ⭐	R2R Discord Server 💬

Here's a Quick Recap (only for you) 🙈

Below is a table that contains the list of all the RAG Frameworks mentioned in this blog:

Framework	Key Features	Use Cases	Why Choose It?
LLMWare	End-to-end RAG pipeline, hybrid search, multi-LLM support	Enterprise search, document Q&A, knowledge retrieval	Highly optimized for unstructured data processing
LlamaIndex	Data connectors, structured retrieval, adaptive chunking	RAG-based chatbots, document search, financial/legal data analysis	Strong ecosystem with integrations and indexing optimizations
Haystack	Modular RAG, retrievers, rankers, scalable inference	Enterprise AI assistants, Q&A systems, contextual document search	Powerful for production-ready search applications
Jina AI	Neural search, multi-modal data, vector indexing	AI-powered semantic search, image/video/text retrieval	Scalable and fast for AI-driven search solutions
Cognita	RAG with knowledge graphs, retrieval re-ranking	AI-driven knowledge graphs, intelligent document search	Advanced retrieval using structured and unstructured data
RAGFlow	Graph-enhanced retrieval, hybrid search, deep document processing	Legal, finance, research document retrieval	Enterprise-ready, scalable, optimized for structured search
txtAI	Lightweight RAG, embeddings-based retrieval, easy deployment	Document similarity search, lightweight search engines	Fast and simple RAG for developers needing flexibility
STORM	Multi-hop retrieval, knowledge synthesis, LLM chaining	AI-driven research assistants, contextual understanding	Optimized for complex knowledge retrieval tasks
LLM-App	Fast streaming RAG, parallel retrieval, scalable indexing	Live AI chatbots, customer support automation	Efficient RAG with fast response time for high-load applications
Neurite	Multi-agent reasoning, multi-modal retrieval	Research assistance, AI-powered document analysis	Supports multi-modal inputs and collaborative AI reasoning
R2R	Reasoning-based retrieval, automated knowledge extraction	Scientific document processing, in-depth Q&A	Tailored for complex and logical reasoning in RAG

But wait, Why can't we use LangChain over RAG Frameworks??

While LangChain is a powerful tool for working with LLMs, it is not a dedicated RAG framework. Here’s why a specialized RAG framework might be a better choice:

LangChain helps connect LLMs with different tools (vector databases, APIs, memory, etc.), but it does not specialize in optimizing retrieval-augmented generation (RAG).
LangChain provides building blocks for RAG but lacks advanced retrieval mechanisms found in dedicated RAG frameworks.
LangChain is good for prototypes, but handling large-scale document retrieval or enterprise-level applications often requires an optimized RAG framework.

Conclusion: Choosing the right framework 😉

With a variety of open-source RAG frameworks available—each optimized for different use cases—choosing the right one depends on your specific needs, scalability requirements, and data complexity.

If you need a lightweight and developer-friendly solution, frameworks like txtAI or LLM-App are great choices.
For enterprise-scale, structured retrieval, LLMWare, RAGFlow, LlamaIndex, and Haystack offer robust performance.
Jina AI and Neurite are well-suited for the task if you focus on multi-modal data processing.
For reasoning-based or knowledge graph-powered retrieval, Cognita, R2R, and STORM stand out.

Finally, we are at the end of the blog. I hope you found it insightful. Please save it for the future. Who knows, when you need it!

Follow me on Github

RS-labhub (Rohan Sharma) · GitHub

Hi there!🧟 You're the most beautiful person I've ever met! - RS-labhub

github.com

Thank you so much for reading! You're the most beautiful person I ever met. I have a lot of trust in you. Keep believing in yourself, and one day you will become motivation for others. 💖

Creating and Managing a nextJS Event Planning Website with Daytona! 🐦‍🔥

Rohan Sharma — Mon, 06 Jan 2025 04:30:03 +0000

It's been a long time since I wrote a blog. Let's make this happen!

This blog will focus on three things.

Part a: A quick details about the event management website "Festigo"
Part a: What is Daytona and how does it make things easier?
Part b: Event Planning System Overview and Workflow

This blog is going to be little different and a lil bit of tutorial type also. But I'm sure you're going to like it! Let's start without wasting time!

3... 2... 1... 🟢

What is Festigo?

Festigo is an event planning and event organizing website that brings guests, vendors, and event organizers(the people hosting the event) under a single umbrella. Apart from organizing different types of events, from birthdays to giveaways and beyond, our platform also streamlines the planning and coordination process for various events. With vendor management capabilities, vendors can efficiently handle multiple events across different dates simultaneously. Moreover, our platform empowers event organizers to manage multiple events concurrently, eliminating the need for them to juggle communication between various vendors.

Tech Stack

NextJS
Tailwind CSS
Postgres DB
Prisma ORM
Typescript

Festigo comes with these super features

Onboarding Event Organizers: Event organizers, such as couples planning a wedding, will need to register and create profiles to utilize the application effectively.
Inviting Vendors: Organizers can invite vendors from their contacts by sharing invitation links via email or text directly from the platform.
Event Management: Organizers can create and manage multiple events simultaneously, each with its own details and dates.
Collaborative Chat Spaces: Users, including vendors and organizers, can create chat rooms for seamless coordination and synchronization during event planning.
One-on-One Chats: Users can engage in direct messaging, allowing for private conversations between vendors and organizers.
Multi-Event Navigation: Both organizers and vendors can seamlessly navigate between multiple events and access event-specific details with ease.
Event Scheduling: The application will feature a calendar system for planning various events, complete with reminders and RSVP functionality.
User-Friendly Interface: Festigo boasts a user-friendly and mobile-responsive design, ensuring effortless navigation across its different sections.
Guest List Management: Organizers can create guest lists, invite guests to the platform, and track attendance through RSVPs.

Github Link: https://github.com/RS-labhub/Festigo

Now let's start this blog!!! Yayyyyyyy!! 🙂

What is Daytona??

Have you ever heard of cloud-based development environments??

No??

No worries. Cloud-based development environments are those environments where you can create a container or virtual machine dedicated to development.

Didn't understand?? Let me simplify for you.

A cloud-based development environment is a virtual workspace accessible through the internet, where developers can code, test, and deploy applications using pre-configured tools, libraries, and infrastructure hosted on a cloud provider's servers.

This was the only pre-requisite to know about Daytona! Now, it will be easier to understand.

Daytona is also a cloud-based development environment. Unlike Github Codespaces, which supports only Github as a code host. Daytona supports multiple code hosts or git providers like GitHub, GitLab, Bitbucket, and Gitea (even more options than Gitpod).

What is special about Daytona?? Daytona is open-source comes under Apache license 2.0 and supports VS Code/Jet Brains as IDE. Isn't cool??

But Why to setup a Virtual Machine??
Try to find it yourself. And let me know what you get in the Comment section. 😉

Star Daytona on Github ⭐

Let's try to setup our project on Daytona 🥹

Daytona is easy to use and very simple to understand. But, the first time is always special. (⚠️ dark meme alert? No. Your mind is dirty. I'm very pure with my thoughts 🥹😂)

Step 1:
Install Daytona on your local machine. (one-time effort). Before installing, please read the system requirements first, or in the end you'll throw me some beautiful cursed words.

Operating System	Installation Command
Linux	`bash -c "$(curl -sf -L https://download.daytona.io/daytona/install.sh)" && daytona server -y && daytona`
macOS	`bash -c "$(curl -sf -L https://download.daytona.io/daytona/install.sh)" && daytona server -y && daytona`
Windows	$architecture = if ($env:PROCESSOR_ARCHITECTURE -eq "AMD64") { "amd64" } else { "arm64" } md -Force "$Env:APPDATA\bin\daytona";[System.Net.ServicePointManager]::SecurityProtocol =[System.Net.SecurityProtocolType]'Tls,Tls11,Tls12'; Invoke-WebRequest -URI "https://download.daytona.io/daytona/v0.50/daytona windows-$architecture.exe" -OutFile "$Env:APPDATA\bin\daytona\daytona.exe"; $env:Path += ";" + $Env:APPDATA + "\bin\daytona"; [Environment]::SetEnvironmentVariable("Path", $env:Path,[System.EnvironmentVariableTarget]::User); daytona serve;
Homebrew	`brew tap daytonaio/tap` and then `brew install daytona`
Nix	`nix-shell -p daytona-bin`

Step 2:
Now in this step, we are going to configure our freshly installed package. Again, a one-time effort. 😉

1️⃣ Add a Git Provider:

 daytona git-providers add

This will allow you to perform Git operations w/o repeated authentication. When you run the above command, you'll get some options like GitHub, GitLab, Bitbucket, Other. Select the one you're comfortable with. Then you'll be asked to put in the Personal access token. You can skip the further step. And you're done!

2️⃣ Install a Provider:

 daytona provider install

It will provide the interface with the Daytona Server to manage and deploy your workspaces. When you run this command, you'll be prompted with some options. Choose your provider based on your preference. (I'll go with docker provider)

3️⃣ Set a Target:

 daytona target set

Targets specify the precise location or platform where these environments will reside. When you run the above command, you get a TUI form (Terminal interface), where you have to add your selected provider details.

Step 3:
If you've done with the above steps. Then you're good to go! You did all the hard work, and now it's time to create a workspace where we will be working.

But before creating a workspace, we need to create a devcontainer.json. I know you must be thinking, what the hell is this? A devcontainer.json file in your project tells VS Code how to access (or create) a development container with a well-defined tool and runtime stack. This file is mandatory for Daytona to create a workspace.

If you want to create a devcontainer.json file, you can use devcontainer.ai provided by Daytona itself. But remember AI can make mistakes. Conventionally, we put devcontainer.json file inside .devcontainer folder. But why?? Ask me in the comment section. 🙂

Let's create a quick devcontainer.json file for our festigo project:

{
    "name": "Festigo Dev Container",
    "image": "mcr.microsoft.com/devcontainers/javascript-node",
    "forwardPorts": [3000],
    "postCreateCommand": "cd festigo && npm install"
}

Let's jump inside this code.

name: It specifies the name of the container. It can be any.
image: It specifies the Docker image to be used for the container. mcr.microsoft.com/devcontainers/javascript-node is a pre-configured Docker image designed for JavaScript and Node.js development. It includes necessary tools and dependencies for Node.js projects, provided by Microsoft.
forwardPorts: It allows the specified port(s) on the container to be forwarded to your local machine.
postCreateCommand: As the name suggests, it specifies the command to run after the container is created and set up.

Step 4:
It's time to Create a Workspace. We can create a workspace by running the below command.

daytona create repo_url

In our case, it's going to be:

daytona create https://github.com/RS-labhub/Festigo

And we are done!!! A workspace will be created and we are ready to code or make changes inside it. Maybe you find it difficult for the first time, but it's just for one time. And you'll be good to go! You can create as many workspaces as you want at a time and you'll never run out of credits.

Festigo (Event Planning Website): Overview and WorkFlow 🎉

I have already explained in the above section that "what is festigo?" and what it will be doing.

Imagine you're planning an event or you have to organize one. You've got to arrange for a flower decorator, a DJ, and many more vendors. Coordinating between them all can be incredibly challenging without proper planning, especially if you’re doing it for the first time. To solve this hectic problem, we, the team- Twilight Ties, introduce you with our application Festigo to save your time as well as your drudgery. Festigo serves as a centralized solution, seamlessly connecting you with all necessary vendors and facilitating smooth coordination between them. Whether it's ensuring the flowers groove with the beats or orchestrating a perfectly synchronized schedule, our platform sweeps away the stress of juggling multiple aspects of your special day.

To solve this problem, we made Festigo. It was a team project for a hackthon, let say X. Before explaining further, I want to thank my team mates. Thanks a lot Niharika, Himanshu, and Adarsh for your awesome work. You guys are super awesome!

My role in building Festigo was to design the full interface and then contribute to the frontend part. For designing, I opted Figma.

This image speaks a lot. A super short description of our project. But due to some reasons, we won't be able to complete it fully. If want to be a part of this awesome project, then comment below and we will work together and finish it. It solves a real-world problem, so need to give further justification on why you should work on this.

WorkFlow 🌊

This is how we're planning to make it. The concept is simple as we don't want to complicate things at this stage. But yeah, we too know some top cases and edge cases that will panic during the implementation. But let's hope for the best.

How it should look like- The UI 🤔

The design is final upto a max extent. But we do like suggestions and changes will be made. The design is just for a quick reference and not a professional one. So, don't judge it, please. I made with too much work and within a week you know.

Figma Prototype link: Festigo Full Working Figma Prototype

And here's the explanation of the design: https://www.youtube.com/watch?v=Paq7I1Ru22s (it will make you easier to understand what we are trying to achieve)

Engineered Prototype: Work in Progress 🙂

Of course, if we have a git repo. It means we have some work done!

If you're facing trouble in getting started. Then watch this YouTube video:

So, let's setup Daytona and work together on this beautiful project. The maximum work is done, but we just want to finish it and launch this in the market.

A little story of Daytona and I that made me a bounty hunter. [optional to read]

Again, I get to know about Daytona through Quira. If you still don't know about Quira, then read this blog: https://dev.to/rohan_sharma/quira-monetise-your-open-source-work-10e3

I saw this project is open-source and then I tried to contribute. And some contributions, the project was funded. Now, they started to add a bounty to every issue almost. This is where I started to hunt bounties. I solved almost 10 GH issues of Daytona (not a great number I know.) of which around 6-7 of them are with bounty.

Here's a list of all my successful PRs:

fix: properties missing from server config view: https://lnkd.in/gsgFTibR (claimed bounty 💃)
fix: properties missing from server config view: https://lnkd.in/gsgFTibR (claimed bounty 💃)
fix: Using git providers hosted without HTTPS fails to clone repositories: https://lnkd.in/gQ2-msnV
fix: devcontainer config file name validation: https://lnkd.in/gzBy8bFk
bug fix: sudo dockerd removed: https://lnkd.in/gzHMNjah
fix: quitting the profile TUI results in FATAL_ERR: https://lnkd.in/gimd_njj (claimed bounty 💃)
Fix: Status code issue: https://lnkd.in/gDTg4D_9 (claimed bounty 💃)

And 2-3 others. I guess I didn't post them on Linkedin, else I would be able to find them. Haha, no worries. 😊

And the part you all are waiting for. #Conclusion ☠️

Daytona is a super cool cloud-based development environment (virtual machine) that allows you to give rest to your local system and work in a more powerful environment.

Daytona not only provides you your personalized workspace for free but also provides bounties to solve their GH issues. All you need is some expertise in GoLang. Again, don't try to spam.

Please support them, and at least give them a star.
Star Daytona on Github ⭐

Also, you can follow me on Github.
Follow Me on Github ⭐

That's all for today. Thank you so much for you time. You're doing good in your life. We all feel motivated at a moment of time. But this is where you have to move on. Have some faith and trust in yourself. The path you're walking on is not simple. Many ppl are proud on you, including me. 💘

DEV Community: Rohan Sharma

My Docs Are Safer Than My Search History 😎

What's This All About? 🤔

The Cool Features That'll Make You Go "Woah!" 🚀

1️⃣ Four Roles, Four Levels of Trust

2️⃣ Document Security That Actually Makes Sense

3️⃣ AI That Works For YOU (Not For Big Tech)

4️⃣ Organizations That Don't Mix Like Oil and Water

How GitHub Copilot CLI Supercharged My Development 🚀

What is GitHub Copilot CLI?

How I Used It in This Project

Why Copilot CLI is a Game Changer

The Tech Magic Behind the Curtain 🎩✨

Built With Love Using:

Security Layers:

Document Support:

The Boyfriend-Girlfriend Analogy That'll Make You Understand Permissions 💑

Real-World Use Cases

For Teams:

For Content Creators:

For Students:

The Journey (AKA The Fun Part) 🎢

Challenge #1: Role-Based Access Control

Challenge #2: Organization Isolation

Challenge #3: Encryption That Doesn't Break

Challenge #4: God's Multi-Org Publishing

The Tech Implementation (For My Developer Friends)

Permission Checking:

Document Deletion Logic:

AI Action Flow:

Organization Membership:

Try It Yourself!

What's Special About This Project?

1. Security First

2. No Vendor Lock-In

3. Real Enterprise Features

4. Actually Good UX

5. Named After Someone Special

6. Built with GitHub Copilot CLI

Why This Project for the GitHub Copilot CLI Challenge? 🏆

Final Thoughts

Links & Contact

Creating a Chatbot that actually Stands Out! (vibe coded version)🦖

Let's start building our Chatbot!

Design it.

Start implementing the Core Features

Adding a Database (optional)

You're so done!

RS-labhub / Radhika

Radhika is a multi-model AI assistant built for your mood and friendship 💞

Radhika

Detailed Explanation

Features

Quick Start

License

Conclusion

2025 in Review: Growth, Grief, and the Cost of Momentum

Now's let me write what you're most interested in reading

Things I loved the most!!!

What I Achieved!!!

How to Create a Local Chatbot Without Coding in Less Than 10 Minutes on AI PCs

Step 1: Download Model HQ

Step 2: Choosing the Right AI Model

Available Model Options:

Step 3. Downloading Models

Step 4: Start Chatting

Customizing Your Chat Experience

Step 5: Integrating Sources for Enhanced Responses

Example: Using a Document as a Source

Chatting with Images

Step 6: Saving and Downloading Results

Step 7: Exploring Advanced Features

Future Updates and Community Engagement

Why This Matters

Conclusion: Get Started with Model HQ Today!

Here's how I created a Real-Time Discord Badge for Github Readme 🌠

Why did I build this?

Why add Discord Live Members Count Badge to your GitHub Readme?

Step-by-Step Guide: Adding Discord Live Members Count Badge to Your GitHub README

Step 1: Add the Live Count Bot to Your Server

Why add `Discord Live Members Count Badge` to your GitHub Readme?

Step-by-Step Guide: Adding `Discord Live Members Count Badge` to Your GitHub README

Step 1: Add the `Live Count Bot` to Your Server

`discord-members` API

`discord-bots` API

`discord-total` API

`fetchAllMembers` Utility

Welcome to `RS PORTFOLIO` 👋