DEV Community: Yash Kumar Saini

Turning Weekly GitHub Activity Into Blog Posts on Notion + DEV.to

Yash Kumar Saini — Fri, 27 Mar 2026 19:07:08 +0000

This is a submission for the Notion MCP Challenge

What I Built

Every Monday standup, someone asks: "What did you work on last week?" And every Monday, I stare at my screen trying to remember. Did I merge that PR on Wednesday or Thursday? Was that refactor in the auth module or the pipeline? How many repos did I even touch?

I got tired of that blank moment. So I built DevNotion — a 3-agent pipeline powered by Mastra that harvests my entire week of GitHub activity, narrates it into a first-person blog post using Gemini, and publishes it to Notion (as a planner-style page with structured tables) and DEV.to (as a draft article). Every Sunday, automatically, via GitHub Actions.

No more Monday amnesia. The blog writes itself.

What it actually does

Harvests my GitHub activity via GraphQL — commits, PRs, issues, code reviews, discussions, language stats, contribution streak
Narrates the raw data into a casual, first-person blog post using Gemini (with a deterministic fallback if the LLM is unavailable)
Publishes to two platforms simultaneously:
- Notion — a planner-style page with stats tables, repo breakdowns, PR/issue/review tables, language breakdown, and the full blog post
- DEV.to — a draft article ready for review

Key features

3 specialized agents — each does one thing well (harvest, narrate, publish)
LLM only where it adds value — harvest and publish are deterministic, zero token overhead
4 blog tone profiles — casual (default), professional, technical, storytelling
Planner-style Notion pages — not just a wall of text, but structured tables with stats, repos, PRs, issues, reviews, and languages
Notion MCP integration — full Notion API surface via Model Context Protocol
Notion Markdown Content API — write rich markdown directly to pages (the real game changer)
DEV.to draft publishing — articles created as drafts, ready to review and publish
GitHub Actions CI — weekly cron (Sundays 08:00 UTC) + manual dispatch
Blog log in README — CI auto-commits a metrics table after each run
Fallback chain — always produces a blog post, even if Gemini is down
Rate limiting everywhere — p-queue + p-retry for both Notion and DEV.to APIs

Architecture

Step	Agent	What it does
Harvest	`github-harvest-agent`	Fetches weekly GitHub data via GraphQL (deterministic)
Narrate	`narrator-agent`	Writes a first-person blog post from the data
Publish	`publisher-agent`	Creates Notion planner page + DEV.to draft via direct APIs

The pipeline only uses an LLM where it genuinely adds value — narration. Harvest and publish are pure function calls. No token overhead, no hallucination risk, faster execution.

Architecture Deep-Dive

Why 3 agents, not 1?

I could've built one mega-agent that does everything. But that's a recipe for:

Burning tokens on deterministic work (fetching GitHub data doesn't need an LLM)
Hallucinating URLs and stats (the publish step should never make things up)
Debugging nightmares (which part of the monolith failed?)

Instead, each agent is a specialist. The workflow chains them together:

export const weeklyDispatchWorkflow = createWorkflow({
  id: 'weekly-dispatch',
  inputSchema: z.object({ weekStart: z.string() }),
  outputSchema: PublishOutputSchema,
})
  .then(harvestStep)
  .then(narrateStep)
  .then(publishStep)
  .commit();

Three steps, chained with .then(), committed as a single workflow. Mastra handles the data handoff between steps automatically.

Harvest: deterministic data, zero LLM

The harvest step calls GitHub's GraphQL API directly — no agent reasoning needed:

const harvestStep = createStep({
  id: 'harvest-github',
  inputSchema: z.object({ weekStart: z.string() }),
  outputSchema: WeeklyDataSchema,
  execute: async ({ inputData }) => {
    const data = await fetchWeeklyContributions(inputData.weekStart);
    return WeeklyDataSchema.parse(data);
  },
});

One GraphQL query pulls commits, PRs, issues, reviews, discussions, language stats, and contribution streak for the week. The response gets validated through a Zod schema. No LLM in the loop — this is pure data fetching.

Narrate: LLM with a fallback chain

This is where the LLM earns its keep. The narrator agent takes raw JSON and writes a blog post that sounds like I wrote it myself. The system prompt has a full personality profile — it writes in first person, knows my tech stack (Python, Rust, TypeScript), references my OSS work, and matches one of four tone profiles.

But LLMs can be flaky. So the narrate step has a fallback chain:

const narrateStep = createStep({
  id: 'narrate',
  execute: async ({ inputData, mastra }) => {
    const agent = mastra!.getAgent('narrator-agent');
    let blog;

    try {
      const result = await agent.generate(prompt);
      const parsed = parseFrontmatter(result.text);
      if (parsed.success) {
        blog = parsed.data.blog;
      } else {
        blog = buildFallbackNarration(inputData).blog;
      }
    } catch (err) {
      blog = buildFallbackNarration(inputData).blog;
    }

    return { blog, weeklyData: inputData };
  },
});

Gemini generates a markdown blog with YAML frontmatter
If parsing fails → deterministic fallback builds a basic post from raw data

A blog post is always produced, even if Gemini is completely down.

Publish: Notion planner + DEV.to draft

The publish step is where things get interesting. It doesn't just dump text into Notion — it builds a planner-style page with structured tables:

const publishStep = createStep({
  id: 'publish',
  execute: async ({ inputData }) => {
    const { blog, weeklyData } = inputData;

    // 1. Create Notion page
    const createResult = await createNotionPage(title);

    // 2. Create DEV.to draft (so the link goes into the Notion planner)
    const devtoResult = await createDevtoArticle({
      title: blog.headline,
      body_markdown: buildDevtoMarkdown(blog),
      tags: blog.tags,
      published: false,
    });

    // 3. Write planner markdown to Notion (includes DEV.to link)
    const plannerMd = buildPlannerMarkdown(weeklyData, blog, links);
    await writeNotionMarkdown(notionPageId, plannerMd);
  },
});

The order matters: DEV.to draft gets created before writing the Notion page content, so the Notion planner can include a link to the DEV.to draft. Cross-platform linking, done right.

Each Notion page includes:

Published Links table — Notion page URL + DEV.to draft edit link
Week at a Glance — commits, PRs, issues, reviews, lines added/removed, streak
Active Repositories — repo name, commits, language, line changes
Pull Requests / Issues / Reviews / Discussions — structured tables
Languages — top languages by commit count
Full blog post — the narrated content below a separator

// Detect dark theme var iframe = document.getElementById('tweet-2038152048533979142-162'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2038152048533979142&theme=dark" }

Star DevNotion on GitHub

How I Used Notion MCP

This is the part I'm most excited about. DevNotion uses the Notion MCP Server in two complementary ways:

1. Notion MCP Server via `@mastra/mcp`

The publisher agent integrates with the official @notionhq/notion-mcp-server through Mastra's MCP client. This gives the agent access to the full Notion API surface via Model Context Protocol:

import { MCPClient } from '@mastra/mcp';

export const notionMcp = new MCPClient({
  servers: {
    notion: {
      command: 'npx',
      args: ['-y', '@notionhq/notion-mcp-server'],
      env: {
        OPENAPI_MCP_HEADERS: JSON.stringify({
          Authorization: `Bearer ${env.NOTION_TOKEN}`,
          'Notion-Version': '2022-06-28',
        }),
      },
    },
  },
  timeout: 30000,
});

The MCP tools are loaded lazily with a graceful fallback — if the MCP server fails to start, the direct tools still work independently:

export async function getNotionMcpTools(): Promise<Record<string, any>> {
  try {
    return await notionMcp.listTools();
  } catch (err) {
    console.warn('MCP: Notion MCP server unavailable, using direct tools only');
    return {};
  }
}

2. Direct tools + MCP tools merged

The publisher agent merges both tool sets — MCP tools for the full Notion API surface, and direct tools for capabilities MCP doesn't cover:

// Direct tools (Markdown Content API + DEV.to — not available via MCP)
const directTools = {
  createNotionPage: createNotionPageTool,
  writeMarkdown: writeMarkdownTool,
  searchNotion: searchNotionTool,
  updateNotionPage: updateNotionPageTool,
};

// Merge: Notion MCP tools + direct tools
const mcpTools = await getNotionMcpTools();
const tools = { ...mcpTools, ...directTools };

This dual approach means the publisher agent gets the best of both worlds — MCP's broad API surface for interactive use in the Mastra playground, plus direct tools for the automated workflow.

3. The Markdown Content API (the game changer)

This is the Notion feature that made the planner-style pages possible. Instead of constructing Notion blocks one by one (which is painful and rate-limit-heavy), I write the entire page as markdown in one API call:

const response = await fetch(
  `https://api.notion.com/v1/pages/${pageId}/markdown`,
  {
    method: 'PATCH',
    headers: {
      Authorization: `Bearer ${env.NOTION_TOKEN}`,
      'Content-Type': 'application/json',
      'Notion-Version': '2026-03-11',
    },
    body: JSON.stringify({
      type: 'replace_content',
      replace_content: { new_str: markdown },
    }),
  },
);

One PATCH request replaces the entire page content with rich markdown — including tables, headings, blockquotes, links, code blocks, everything. This is what powers the planner-style layout with structured stats tables + the full blog post, all in a single API call.

4. Rate limiting

Notion's API allows roughly 3 requests per second. Every Notion call (MCP and direct) goes through a shared rate limiter:

const queue = new PQueue({ concurrency: 1, interval: 334, intervalCap: 1 });

async function rateLimited<T>(fn: () => Promise<T>): Promise<T> {
  return queue.add(() => pRetry(fn, { retries: 3 })) as Promise<T>;
}

p-queue throttles concurrency, p-retry handles transient failures. I learned this the hard way — without rate limiting, the Notion API will 429 you into oblivion when you're creating a page, writing markdown, and updating the icon in quick succession.

Lessons Learned

Rate limits are the real boss

Notion (3 req/s), DEV.to (30 req/30s), GitHub GraphQL (5000 points/hr) — every API has its own throttle. I ended up with p-queue + p-retry wrappers around everything. The rate limiter code is almost identical across all three services, and honestly, it should probably be a shared utility. But three similar lines of code is better than a premature abstraction.

Structured output is slower than you'd think

I originally used Gemini's native JSON schema for structured output (agent.generate(prompt, { structuredOutput: { schema } })). It worked, but added 20-40 seconds per call. Switching to plain text generation with YAML frontmatter parsing was 3-4x faster and just as reliable. The deterministic fallback catches the rare parsing failure.

Gemini model musical chairs

I've been through three Gemini models on this project: gemini-2.5-flash-preview-04-17 (retired), gemini-2.5-flash (stable but slow for structured output), and now gemini-3-flash-preview (current). The lesson: always make the model configurable via env vars. Hardcoding model IDs is a recipe for broken deploys.

The Zod conflict that broke everything

Mastra and my code both depend on Zod, but different versions. Having two Zod instances means z.string() from one isn't recognized by the other — schema validation just silently fails. The fix: a single line in package.json:

{
  "pnpm": {
    "overrides": {
      "zod": "$zod"
    }
  }
}

Forces pnpm to deduplicate to one Zod version. Took me way too long to figure that out.

Direct API calls beat agent reasoning for deterministic work

The harvest and publish steps started as full agent calls. But an LLM doesn't add anything when the task is "call this GraphQL endpoint and return the result." Switching to direct function calls made the pipeline faster, cheaper, and more predictable. Only use an LLM where you need creativity or reasoning — everywhere else, just write a function.

Built with Mastra, Gemini, Notion API, and a lot of coffee. If you've ever forgotten what you worked on last week, give DevNotion a try.

Simulating P2P Attacks and Teaching AI to Resume Sessions

Yash Kumar Saini — Fri, 27 Mar 2026 18:12:28 +0000

TL;DR

It’s been one of those weeks where the terminal never really closed. I clocked 78 commits and pushed 4 PRs across 9 different repositories, maintaining a perfect 7-day streak. The bulk of the heavy lifting happened in the P2P space—specifically simulating network attacks—and adding some much-needed session persistence to my AI coding tool, nanocoder. With over 21,000 lines added and about 6,500 deleted, it was a high-output week focused on building out complex systems and then immediately refining them.

WHAT I BUILT

The star of the show this week was definitely P2P-Attack-Simulation. I’ve been obsessed with how decentralized networks handle adversarial conditions, and I finally merged a massive PR for Topology ts simulation. We’re talking 18,756 additions and 6,436 deletions. I essentially rewrote how the network topology is represented in TypeScript to make it more modular. Before, the simulation was a bit too rigid; now, I can spin up different node behaviors and see how the gossip protocols hold up when half the network starts acting malicious. It’s one thing to read about Sybil attacks in a paper, but seeing the message propagation latency spike in your own simulation is a different kind of satisfying.

Over in nanocoder, I spent a good chunk of time on the developer experience. If you’ve used AI coding assistants, you know the pain of losing context or having to restart a session from scratch. I implemented a new Feature /resume command to continue session. This involved a fair bit of state management (about 2,300 lines of code) to ensure that when you come back to a project, the AI knows exactly where you left off. It’s all about reducing friction. I want to spend my time coding, not re-explaining my file structure to a LLM.

I also dipped back into the low-level world with the networking repo. This is where I get my Rust fix. I merged two PRs here: one to Implement proper RST generation and another to refactor: remove timer module and associated functionality. The RST (Reset) generation is crucial for proper TCP handling—basically telling the other side "I have no idea what you're talking about, let's start over." The refactor felt great, too. I realized the custom timer module was overkill for what we needed, so I ripped out 137 lines of brittle code. Less code, fewer bugs.

Beyond the big features, I kept the wheels turning on several other projects. I pushed 10 commits to py-libp2p and 1 to dotnet-libp2p, mostly keeping the Python and C# implementations of the p2p stack in sync. I also spent some time tweaking my environment, with 8 commits to my nvim config (because a dev's work is never done when it comes to Lua plugins) and 7 commits to my notes repo, which is where I dump my raw thoughts on C and systems programming.

PULL REQUESTS

I managed to get four significant PRs merged this week, and they really tell the story of my transition from "building the foundation" to "polishing the experience."

The Topology ts simulation PR was the most exhausting but rewarding. It wasn't just about adding lines; it was about restructuring the entire simulation engine. I had to ensure that the TypeScript types correctly reflected the state of a peer at any given millisecond during an attack.

On the AI side, the Feature /resume command in nanocoder was a fun challenge in serialization. Making sure the session state could be saved and reloaded without losing the "vibe" of the conversation took a few iterations, but it's finally in a place where it feels seamless.

The Rust work in the networking repo was much more surgical. Implementing RST generation required me to get back into the weeds of packet headers, while the timer module refactor was a classic "addition by subtraction" move.

CODE REVIEWS

I only did one formal review this week, but it was a deep one. I looked at a PR for py-ipld-dag titled Add Block API, IPLD data model, codecs, registry, and tests.

I actually ended up requesting changes on this one. IPLD (InterPlanetary Linked Data) is the backbone of how we structure data in the p2p world, and the proposed implementation of the Block API felt a bit too coupled to specific codecs. I suggested a more registry-based approach to make it easier for others to plug in new data formats later. It’s important to get these base-level APIs right early on, or you end up paying for it in technical debt for years.

TECH STACK

This week was a true polyglot marathon.

TypeScript was my primary driver for the simulation work and the AI tooling. With over 15 million bytes of TS in my environment, it’s definitely my "get things done" language. But Python isn't far behind—especially with the work on py-libp2p and the IPLD reviews.

The Rust work in the networking repo reminded me why I love the language: the compiler is a jerk until you get it right, and then your code just works. I also touched some Lua for my Neovim setup and a bit of C for my personal notes and experiments.

My add/delete ratio was pretty high (21k vs 6k), which usually means I'm in a heavy feature-building phase. However, that 6k deletions in the P2P repo shows I'm not just piling code on top of code—I'm actively replacing the old stuff as I go.

And yeah, that 7-day streak feels good. It wasn't a forced grind; I just genuinely had something I wanted to solve every single morning when I woke up.

WHAT'S NEXT

Next week, I’m planning to take the P2P simulation even further. Now that the topology is flexible, I want to start implementing specific Eclipse attack scenarios to see how quickly a node can be isolated from the rest of the network.

I’m also keeping an eye on the feedback for the /resume command in nanocoder. There are probably some edge cases with large file buffers that I’ll need to iron out.

On the Rust side, now that RST generation is handled, I might start looking into better congestion control mechanisms for the networking library. There’s always more to optimize. See you in the commit logs!

Beyond the Panic: Hardening the Rust SDK

Yash Kumar Saini — Fri, 27 Mar 2026 14:41:20 +0000

TL;DR

Engineering is often the art of managing the "unhappy path." This week was a testament to that philosophy. With 74 commits, 2 PRs, 3 issues, and 3 reviews across 5 repositories, the focus shifted from building new features to fortifying the foundations. The headline? A concerted effort to purge unwrap() and panic calls from our Rust SDKs in favor of robust, Result-based error handling.

The Work: Velocity in the Engine Room

The bulk of the week's momentum was concentrated in the Python ecosystem, specifically within p2pCalc and AgentPay. These two repositories accounted for 54 of the week's 74 commits, representing a high-velocity push in our core logic layers.

p2pCalc & AgentPay

In p2pCalc (32 commits), we focused on the computational integrity of our peer-to-peer logic. While the additions and deletions were kept internal to the commit history, the sheer volume of activity suggests a deep dive into the algorithmic core. Parallel to this, AgentPay (22 commits) saw significant movement. When dealing with payment agents, there is no room for ambiguity. My focus here was on ensuring that the state machine governing agent transactions is both predictable and idempotent.

DevNotion & The Developer Environment

Meanwhile, DevNotion (14 commits) continues to evolve. As a TypeScript-based project, it serves as the bridge between our raw data and the narratives we share. The work here was iterative, likely refining the very engine that powers these weekly field notes.

I also took a moment to sharpen the saw. Five commits to my nvim configuration (Lua) might seem like minor housekeeping, but for a principal engineer, the editor is the primary instrument. A well-tuned environment isn't a luxury; it’s a prerequisite for the kind of deep work required to handle complex refactors.

The Pull Requests: The Safety Initiative

The most critical architectural work happened within the Appwrite ecosystem. We are currently in the process of maturing the Rust SDK, and that means moving away from "prototype-grade" code.

Title	Repo	State	Impact
fix(rust): replace unwrap/panic with Result-based error handling	sdk-generator	OPEN	Prevents generator-level crashes during SDK synthesis.
refactor: replace unwrap with error handling in Client methods	sdk-for-rust	CLOSED	Shifts error responsibility to the library consumer, avoiding runtime panics.

The PR in sdk-for-rust (#9) was a substantial undertaking, involving 149 additions and 46 deletions. In Rust, using .unwrap() is a debt you eventually have to pay. By replacing these with proper Result types, we ensure that the SDK doesn't bring down a user's entire application just because of a transient network failure or a malformed response. It’s about respecting the caller’s right to decide how to handle failure.

The work continues in sdk-generator (#1398), where I am applying similar logic to the generator itself. If the generator panics, the entire CI/CD pipeline halts. By implementing Result-based handling, we allow the system to fail gracefully and provide actionable feedback.

The Conversations: Setting the Standard

Collaboration this week was centered on documentation and issue tracking. I closed two critical issues in the sdk-for-rust repo:

Issue #8: The bug report that initiated the unwrap() refactor.
Issue #7: The creation of CONTRIBUTING.md.

The latter is particularly important. As we scale, we need to ensure that external contributors understand the quality bar we’ve set. A clear CONTRIBUTING.md is the first step in building a healthy open-source community around the Rust SDK.

The Reviews: Raising the Bar

Reviewing 3 PRs while authoring 2 is a healthy ratio for a week focused on quality. My reviews on awesome-py-libp2p-examples resulted in "CHANGES_REQUESTED" for two separate PRs (#6 and #3).

When reviewing collaborative tools like a "Whiteboard" or "p2p model checking," I look for more than just "does it run?" I look for idiomatic patterns and clear documentation. If an example is meant to be "awesome," it must serve as a gold standard for others to follow. My comments on py-libp2p (#1222) regarding the reorganization of example scripts follow this same theme: structure dictates usability.

The Craft: A Polyglot Reality

This week’s data reveals a truly polyglot workflow. While Python remains the dominant language by volume (over 77MB of context), the most impactful changes were written in Rust and TypeScript.

The add/delete ratio (+227/-80) indicates a week of net-new growth, but the nature of that growth was defensive. We weren't just adding features; we were adding safety nets. The lack of a commit streak this week is a reminder that engineering isn't always a daily sprint; sometimes it’s a series of deep-dive sessions separated by the necessary time to think through architectural implications.

The Horizon

As we look toward next week, the primary objective is to land the open PR in the sdk-generator. Once the generator is hardened, we can begin rolling out these safety improvements across all generated Rust SDKs.

We’ve moved the needle on reliability this week. The transition from "it works" to "it's resilient" is often invisible to the end-user until something goes wrong and the system doesn't crash. That is the quiet victory of the seasoned architect.

Onward.

I Built a TUI That Makes Rust Code Inspection Feel Like Magic ✨

Yash Kumar Saini — Sun, 15 Feb 2026 22:34:42 +0000

This is a submission for the GitHub Copilot CLI Challenge

The "Why Did I Build This?" Moment

Okay so here's the thing. I was working on this Rust project at 2 AM (as you do), trying to figure out where the hell DeserializeOwned was actually implemented. The codebase had like 50,000 lines, and there were these 17 different impl blocks just... everywhere. Scattered across 8 files like someone playing hide and seek with code.

And I'm sitting there thinking about my options:

Fire up VSCode? My SSH connection was lagging harder than my reaction time on Monday mornings
Use grep? Sure, if I wanted to scroll through 400 lines of garbage output
Try ripgrep with regex? I'd rather debug segfaults than write another regex at 2 AM
Make coffee and pretend the problem doesn't exist? Tempting...

But you know what? I got frustrated enough to actually do something about it.

So I built Oracle — basically a code inspector that lives in your terminal and actually doesn't suck to use. And to flex it more, Github Copilot helped me build, review, clean, optimize and vibe code all of this in just under 3 days.

What I Built

So 🔮 Oracle is basically a terminal-based code inspector for Rust projects. Think of it like... if grep and VSCode had a baby, and that baby grew up to be really good at understanding Rust code. No GUI bloat, no browser tabs eating your RAM, just your terminal doing cool stuff.

Here's what it does:

📦 Deep Code Analysis

Look, it parses everything. And I mean everything:

Functions (with those fancy async/const/unsafe badges, plus all the parameters and return types)
Structs (every field, every derive, all the generics — no more squinting at code trying to figure out field types)
Enums (it shows you ALL the variants with their field types spelled out)
Traits (methods, associated types, supertraits, the works)
Impl blocks (both the regular ones and trait implementations)
Modules, type aliases, constants, statics... basically if Rust can define it, Oracle can show it

🔍 Intelligent Search

The search is actually pretty smart (if I do say so myself):

Fuzzy matching that updates as you type (using fuzzy-matcher under the hood)
Context-aware, so when you're in the Functions tab, it only searches functions (no more wading through noise)
You can search for functions like and will get fully qualified paths like serde::de::Deserialize and it just works
Filter stuff by visibility (public/private/crate-level)

📋 Dependency Inspector

This part's kinda cool — it reads your Cargo.toml and shows you:

Your entire dependency tree visualized nicely
Live info from crates.io (descriptions, GitHub stars, license info)
All the crates installed in your ~/.cargo/registry folder
Press o to open docs.rs, press c to open crates.io — boom, instant browser tabs

🎨 Beautiful Themes

Because apparently I care about aesthetics even in my terminal:

Default Dark (clean and professional-ish)
Nord (if you like cool blues)
Catppuccin Mocha (cozy vibes)
Dracula (for the dramatic folks)
Just press t to cycle through them

⚡ Smooth Animations

Yeah I added animations to a CLI tool. Fight me.

Selection highlights that fade in smoothly
Tab transitions that don't feel jarring
Scrolling with momentum (it feels buttery smooth)
Real-time syntax highlighting

Honestly, I spent way too much time on the animations, but they make it feel really nice to use.

Demo

GitHub Repository: github.com/yashksaini-coder/oracle

Quick Start

# Install from source
git clone https://github.com/yashksaini-coder/oracle.git
cd oracle
cargo install --path .

# Run on any Rust project
oracle /path/to/rust/project

# Or analyze current directory
oracle

Sample Usage

# Inspect a famous crate
cargo new test_project
cd test_project
cargo add tokio

# Launch Oracle
oracle

# Now press:
# - Tab 4 times to get to Crates tab
# - Navigate to "tokio"
# - Press Enter
# - Search for "copy" with /
# - Browse copy methods and implementations

My Experience with GitHub Copilot CLI

Alright, confession time: This was my first serious Rust project that involved terminal UI stuff. I'd never touched Ratatui before, barely understood how syn worked, and was basically figuring everything out as I went.

GitHub Copilot CLI basically became my rubber duck, my Stack Overflow, and my patient senior developer all rolled into one. And the best part? I never had to leave my terminal.

🎯 How Copilot Saved My Sanity

1. Wrestling with the `syn` Crate

So Rust's syn crate is amazing for parsing Rust code, but holy hell the learning curve is steep. I needed to extract function signatures, struct fields, enum variants, all the trait bounds... basically everything.

I was staring at the docs feeling like I was reading ancient Greek, so I just asked Copilot:

gh copilot suggest "parse rust struct with syn crate extract all fields and visibility"

And it straight up gave me this:

use syn::{ItemStruct, Fields};

fn analyze_struct(st: &ItemStruct) -> Vec<Field> {
    match &st.fields {
        Fields::Named(named) => {
            named.named.iter().map(|f| Field {
                name: f.ident.as_ref().unwrap().to_string(),
                ty: quote!(#ty).to_string(),
                visibility: parse_visibility(&f.vis),
            }).collect()
        }
        // ... Tuple and Unit variants
    }
}

Like, it just worked. This became the foundation for parsing everything else — enums, traits, impl blocks, you name it. I just extended this pattern to handle all the other Rust item types.

Honestly? Saved me probably 8-10 hours of banging my head against the syn docs. Worth it.

2. Making the TUI Not Look Like Garbage

I wanted something that looked good. Not just functional, but actually pleasant to use. Panels, borders, smooth scrolling, the whole nine yards.

Problem: Ratatui's layout system made my brain hurt. How do you even compose these things?

Asked Copilot: gh copilot explain "ratatui layout constraints horizontal vertical split"

It explained that layouts are basically Lego blocks — you can compose them with Constraint::Percentage and Constraint::Length, and nest them for complex UIs. That made it click.

Then I was like: gh copilot suggest "ratatui scrollable panel with borders and title"

Got this back:

let block = Block::default()
    .borders(Borders::ALL)
    .title(" Inspector ");

let paragraph = Paragraph::new(lines)
    .block(block)
    .scroll((scroll_offset as u16, 0));

Beautiful. That became the core of my inspector panel. Later on I added the animations by interpolating the scroll_offset with some easing functions (because I'm extra like that).

3. Making Search Feel Snappy

I wanted the search to feel like VSCode's Ctrl+P — you know, where you just start typing and boom, instant results. No lag, no BS.

Asked Copilot: gh copilot suggest "rust fuzzy search crate with scoring"

It recommended fuzzy-matcher with SkimMatcherV2. Here's what I ended up with:

use fuzzy_matcher::skim::SkimMatcherV2;

let matcher = SkimMatcherV2::default();
let scored: Vec<_> = items
    .iter()
    .filter_map(|item| {
        matcher.fuzzy_match(&item.name, query)
            .map(|score| (item, score))
    })
    .collect();

scored.sort_by(|a, b| b.1.cmp(&a.1)); // Highest score first

And guess what? It worked perfectly on the first try. No debugging, no tweaking, just... worked. Those moments are rare in programming and should be celebrated.

4. Parsing Cargo.toml Without Crying

Dependencies and Cargo.toml can get complex real fast, especially with workspaces and transitive deps. I needed to parse all of that and build a proper dependency tree.

I was dreading this part until I asked: gh copilot explain "cargo metadata crate rust get all dependencies"

Turns out there's a crate called cargo_metadata (who knew?) that gives you structured JSON output. Copilot showed me:

How to get the root package
How to traverse the dependency tree
How to detect direct vs transitive dependencies
How to handle workspace crates

Here's what came out of it:

use cargo_metadata::MetadataCommand;

let metadata = MetadataCommand::new()
    .manifest_path(&manifest_path)
    .exec()?;

let root = metadata.root_package();
let dependencies = root.dependencies.iter()
    .filter(|d| d.kind == DependencyKind::Normal)
    .collect();

Simple, clean, and it actually works. Love it when code is like that.

5. Fetching Live Crate Info

I wanted to show real crate info when someone's browsing dependencies — descriptions, GitHub stars, license info, all that good stuff. Which meant hitting the crates.io API.

Me, having zero experience with async HTTP in Rust: gh copilot suggest "rust async http request to crates.io api"

Copilot pointed me to reqwest and showed me the blocking client pattern for background threads:

use reqwest::blocking::Client;

fn fetch_crate_docs(name: &str) -> Option<CrateDoc> {
    let client = Client::new();
    let url = format!("https://crates.io/api/v1/crates/{}", name);

    let response = client.get(&url).send().ok()?;
    let json: serde_json::Value = response.json().ok()?;

    Some(CrateDoc {
        name: json["crate"]["name"].as_str()?.to_string(),
        description: json["crate"]["description"].as_str().map(String::from),
        // ...
    })
}

Then I needed GitHub repo stats too, so I asked how to parse GitHub URLs and hit their API. Got that working too.

The whole crates.io + GitHub integration took one evening instead of... I don't know, a week of reading API docs?

6. Cross-Platform Path Hell

You know what's annoying? File paths. Windows uses backslashes, Unix uses forward slashes, and I needed to convert file paths to module paths (src/analyzer/parser.rs → ["analyzer", "parser"]).

Asked: gh copilot suggest "rust strip src directory from pathbuf get module path"

Got this beauty:

fn derive_module_path(path: &Path) -> Vec<String> {
    path.iter()
        .skip_while(|c| c != &"src")
        .skip(1) // Skip "src" itself
        .map(|c| c.to_string_lossy().to_string())
        .collect()
}

Works on Windows, macOS, Linux. No #[cfg] needed. Just works everywhere.

7. Making Animations Not Suck

Okay so this is where I got a bit carried away. I wanted smooth scrolling with momentum, not that janky jump-scroll thing most TUIs have.

Asked Copilot: gh copilot suggest "rust easing functions ease in out cubic"

It gave me the classic easing formulas:

pub fn ease_out(t: f64) -> f64 {
    1.0 - (1.0 - t).powi(3)
}

pub fn ease_in_out(t: f64) -> f64 {
    if t < 0.5 {
        4.0 * t * t * t
    } else {
        1.0 - (-2.0 * t + 2.0).powi(3) / 2.0
    }
}

8. Integrating Copilot within itself

At this point I was just too deep into the rabbit hole and wanted to see how far I can reach, and so decided to give it a AI chat interface area, completely powered by Copilot and guess what ....

It Actually Works, it was mind blowing telling copilot to build and integrate yourself within my tool.

Applied these to scroll offset interpolation and boom — butter-smooth 60fps scrolling. Completely unnecessary for a CLI tool? Yes. Did I do it anyway? Also yes.

The Stuff That Almost Broke Me

Challenge 1: Not Freezing the Terminal When Parsing Big Projects

The Problem: So I tried running Oracle on the tokio codebase (which has like 200+ files), and my terminal just... froze. For a solid 10 seconds. Completely unresponsive. Not great.

The Solution:
I moved all the parsing to background threads so the UI could stay responsive. Added a splash screen with this little wave animation (because if users have to wait, at least make it pretty). Also pre-computed search indices so that wouldn't lag either.

Copilot helped me figure out the threading patterns and how to show progress without blocking the UI. Game changer.

Challenge 2: Making Search Feel Instant (Even When It's Not)

The Problem: When you have 10,000+ items to search through, every keystroke was taking like 100ms. That's noticeable lag, and it felt janky.

The Solution:

Only search within the active tab (if you're in Functions, only search functions)
Limit results to top 50 (nobody scrolls past that anyway)
Used fuzzy-matcher's batch scoring (it's faster than one-by-one)
Cached search results for repeated queries
Only rendered visible items on screen

Result? Search now takes < 16ms per keystroke. That's 60fps territory. Smooth.

Challenge 3: GitHub Rate Limits Are Real

The Problem: The GitHub API rate-limits unauthenticated requests to 60 per hour. I was hitting that limit basically immediately when testing the crates.io features.

The Solution:

Added support for GITHUB_TOKEN environment variable (gives you 5000/hour when authenticated)
Cached responses per crate so we don't re-fetch
Graceful fallback when rate-limited (just show "rate limited" instead of crashing)
Added a hint to users: "Set GITHUB_TOKEN for more requests"

Copilot helped explain the GitHub API auth flow and how to parse rate limit headers. Much better now.

Challenge 4: Scrollable Content That Doesn't Suck

The Problem: When you select an item, the inspector panel shows all its details. But what if the docs are really long? It just got cut off. Not ideal.

The Solution:
Had to track scroll offset per selected item, bind j/k and arrow keys to scroll up/down, show a scrollbar indicator when content overflows, and reset scroll position when switching items.

Copilot showed me Ratatui's Scrollbar widget and how to manage scroll state properly. Works great now.

Why You Might Actually Want to Use This

🚀 It's Fast (Like, Really Fast)

Parses 200+ files in under 2 seconds
Search responds instantly (< 16ms per keystroke)
60fps animations (yes, in a terminal)
Zero network calls for local analysis (your code never leaves your machine)

🎨 It Doesn't Look Like Hot Garbage

4 hand-crafted themes (Nord is chef's kiss)
Smooth scrolling with easing (because I have standards)
Context-aware UI (functions show parameter hints, structs show field types)
Professional documentation formatting

🔧 Actually Designed for Terminal Use

Works perfectly over SSH (no GUI needed, no X forwarding BS)
Vim-style keybindings (j/k for life)
One command: oracle — that's it
Installable via cargo install (once I publish it to crates.io)

📚 It Actually Understands Rust

Most code search tools are just fancy grep. Oracle:

Analyzes ALL Rust item types (functions, structs, enums, traits, impls, modules)
Shows qualified paths (serde::de::Deserialize works perfectly)
Handles visibility modifiers properly
Understands generics, lifetimes, trait bounds, async, const, unsafe — all of it

Basically, it doesn't just search your code, it understands it.

How I Actually Use This Thing

Before Oracle:

# Trying to find all trait implementations
rg "impl.*for" | less  # Scroll through 200 lines of noise

# Trying to understand a struct
rg "struct Config" -A 20 | grep "pub"  # Miss half the fields

# Finding function signatures
rg "pub fn connect"  # Get incomplete matches without parameters

With Oracle:

oracle
# Tab to Functions, type "connect", press Enter
# See:
#   - Full signature with all parameters and types
#   - Complete documentation
#   - Return type with error handling
#   - Source location (file + line number)
# Press 'o' to open in your editor

It's just... so much faster. And less annoying.

Another example: You add tokio to your project and want to understand how spawn works.

Old way:

Clone the tokio repo
grep for "pub fn spawn"
Get 47 matches
Try to figure out which one is the right one
Give up and read the docs instead

With Oracle:

oracle ~/.cargo/registry/src/*/tokio-*
# Press 4 for Crates tab
# Navigate to "tokio", press Enter
# Type "spawn" in search
# See signature, docs, parameters, trait bounds
# Press 'o' for docs.rs if you want more details

Time saved: Like 5 minutes every single time.

Installation & Usage

Install

# From source (recommended for now)
git clone https://github.com/yashksaini-coder/oracle.git
cd oracle
cargo install --path .

# Or use cargo directly (once published)
cargo install oracle-tui

Usage

# Analyze current directory
oracle

# Analyze specific project
oracle ~/code/my-rust-project

# Set GitHub token for better crate.io API limits
export GITHUB_TOKEN=ghp_yourtoken
oracle

What's Next (If People Actually Use This)

Got some ideas for future versions:

Symbol references: Show where a function/type is actually being used (would be super helpful)
Jump to definition: Press a key, open the source file at the exact line
Macro expansion viewer: See what those cryptic macros expand to
Call graph visualization: Show which functions call which (could get messy but cool)
Git integration: Show recent changes per item, like "this function was modified 3 days ago"
Export to JSON/HTML: Generate static docs from your codebase
LSP integration: Hook into rust-analyzer for even deeper analysis

No promises on timeline though. This is still a side project I hacked together because I was annoyed.

Why Rust?

Performance: Parsing is CPU-bound. Rust's zero-cost abstractions mean fast parsing without GC pauses.

Safety: No segfaults when traversing complex ASTs. The borrow checker caught 20+ bugs during development.

Ecosystem: syn is the gold standard for Rust parsing. ratatui makes TUIs actually fun to build.

Cross-platform: One binary works on Linux, macOS, Windows — no Python/Node runtime needed.

Lessons Learned

1. TUI State Management is Hard

Managing focus, scroll positions, search state, animations — all simultaneously — is trickier than React state. Had to build a small state machine.

2. Parsing is Expensive

Even with syn's fast parser, analyzing 200+ files takes time. Had to optimize with:

Lazy loading (only parse visible items)
Caching parsed results
Background threads for heavy work

3. Terminal Rendering is Delicate

Drawing too frequently causes flicker. Drawing too infrequently feels laggy. Found the sweet spot: 60fps when animating, 10fps when idle.

4. Copilot CLI is a Force Multiplier

Seriously. Having an AI explain syn patterns, Ratatui layouts, async patterns, easing formulas — all without leaving the terminal — was incredible.

Wrapping Up

So yeah, that's Oracle. Built it because I was frustrated with existing tools, learned a ton about Rust, TUIs, and parsing along the way.

GitHub Copilot CLI was honestly a lifesaver. Having an AI that could explain syn patterns, show me Ratatui layouts, help with async patterns, and even provide easing formulas — all without leaving my terminal — was incredible. Saved me probably 30+ hours of reading docs and Stack Overflow.

The result is a tool I actually use every day now. Every time I clone a new Rust project, I run oracle first to get the lay of the land. It's just become part of my workflow.

If you work with Rust, give it a shot. Worst case, you wasted 2 minutes installing it. Best case, it changes how you explore code.

Links:

Yash Saini - @yashksaini-coder
X: 0xcrackedDev
GitHub: github.com/yashksaini-coder/oracle
Crates: oracle-tui
Latest Release: Latest releases

Got feedback? Found a bug? Want a feature? Open an issue or drop a comment. I actually read them.

Built with way too much coffee, Rust, Ratatui, and GitHub Copilot CLI being an absolute legend.

Star Oracle

If you liked this, consider giving the repo a star. It makes me feel good about my life choices. ⭐

devchallenge #githubchallenge #cli #rust #tui #opensource

Kleos CLI: Mindsdb Knowledge Base supercharged

Yash Kumar Saini — Mon, 30 Jun 2025 08:46:51 +0000

Okh so lets begin with the important context, currently there is constant evolution going on in the world of AI agents, and there is large amount of unstructured raw data which keeps on increasing, developers need to constantly simplify complex data and accelerate AI workflows to manage this whole data, so they seek help from tools and frameworks that can make thier task easy. With many different database sources, and formats available storing them, managing them and running SQL queries to use them. All of this is very tedious work, one that requires accuracy and fast results.

The perfect solution for this, is the new Knowledge Base :- an an advance system that organizes data with its actual meaning not by just cross matching the frequent words or important keywords.

MindsDB's new Knowledge Base organizes data by its actual meaning, not just by the keywords or frequent words matching
It Supports semantic search with context-aware retrieval
Handles various data sources like databases, CSV, text, and many other integrations like Youtube, Hackernews
Utilizes embedding models, re-ranking models, and vector stores to create embeddings to provide context data retrieval.
Enables intelligent querying and meaningful data discovery

To make interacting with MindsDB's powerful features even more intuitive and efficient, especially its cutting-edge Knowledge Base and AI Agent functionalities, I developed Kleos. Kleos (a greek word which summaries, The enduring transmission of meaningful, wise knowledge — curated, remembered, and used across time.) is a Python-based async command-line interface designed to be your trusty companion for using the MindsDB Knowledge Base.

Every system has its telos — its final cause or purpose. This CLI fulfills the purpose of MindsDB's Knowledge Base: to seek, structure, and serve insight through intelligent agents. Kleos aims to streamline the process of building and managing these intelligent systems directly from your terminal.

This article will walk you through Kleos CLI, highlighting its key features and demonstrating how it leverages MindsDB KB to help you build powerful AI-driven applications with ease.

Core Philosophy: SQL as the Language of AI

One of MindsDB's foundational principles, which Kleos has integrated at root level, is the use of SQL as the primary language for AI development. Instead of requiring developers to learn complex machine learning libraries or manage separate MLOps pipelines for many common tasks, MindsDB allows you to:

Connect to diverse data sources: From your existing databases to SaaS applications and file storages.
Create AI Models: Train models for tasks like classification, regression, time series forecasting, and even interact with large language models (LLMs) for generative tasks.
Build Knowledge Bases: Create semantic search capabilities over your textual data.
Deploy AI Agents: Combine LLMs with your data and KBs to create intelligent assistants.
Query Predictions and Insights: Fetch predictions and insights as if you were querying a regular database table.

All of this achieved by using SQL extensions. Kleos CLI acts as a convenient and powerful interface to execute these SQL commands, manage your MindsDB resources, and automate workflows, making the power of in-database AI more accessible than ever. We've built Kleos using Python, Click for robust command-line parsing, and Rich for beautiful, informative terminal output.

What Kleos can do!

Key Features of Kleos & MindsDB in Action

Kleos provides a comprehensive suite of commands to manage various aspects of your MindsDB environment. Here’s a look at some core functionalities:

1. Seamless Setup (`kleos setup`)

Getting started often involves connecting to your data. MindsDB excels at integrating with numerous data sources. Kleos helps you quickly set up common datasources. For instance, the HackerNews datasource, a popular source for real-time discussions and articles, can be configured with a single command:

kleos setup hackernews --name my_hackernews_data

This simple command tells MindsDB to create a connection named my_hackernews_data that can query HackerNews directly. Kleos ensures this process is smooth, even creating the datasource if it doesn't already exist when you try to use it in other commands.

2. Knowledge Bases (KBs) - The Heart of Kleos (`kleos kb ...`)

Knowledge Bases are a cornerstone of MindsDB's recent advancements, allowing you to embed and search large volumes of text data semantically. Kleos provides extensive support for managing KBs.

a. Creating Knowledge Bases (kleos kb create)

You can easily create a new KB, specifying the underlying embedding models (to convert text to vectors) and optional reranking models (to improve search result relevance). Kleos supports models from various providers like Ollama (for local LLMs) and Google Gemini.

# Create a KB using a local Ollama model for embeddings and google gemini for reranking model

kleos kb create gemini_ollama_kb --embedding-provider ollama --embedding-model nomic-embed-text --reranking-provider gemini --reranking-model gemini-2.0-flash --google-api-key YOUR_GOOGLE_API_KEY --content-columns "question,answer" --metadata-columns "score"

Kleos handles the construction of the CREATE KNOWLEDGE_BASE SQL, including the JSON parameters for model configurations.

b. Ingesting Data (kleos kb ingest)

Once a KB is created, you need to populate it. Kleos simplifies data ingestion, especially from structured sources like the HackerNews tables.

# Ingest the latest 100 stories from HackerNews into 'my_hn_kb'
# This uses smart defaults for content and metadata columns.
kleos kb ingest my_hn_kb --from-hackernews stories --limit 100 --hn-datasource my_hackernews_data

For more control, you can specify which columns map to your KB's content and metadata:

kleos kb ingest my_custom_kb --from-hackernews comments
  --hn-datasource my_hackernews_data
  --content-column "text"
  --metadata-map '{"comment_id":"id", "author":"by", "parent_story":"parent"}' 
  --limit 200

This command translates to an INSERT INTO ... SELECT ... statement, efficiently loading data into your KB.

c. Semantic Search (kleos kb query)

The true power of KBs lies in semantic search. Kleos allows you to query your KBs using natural language, with options for metadata filtering:

# Simple semantic search
kleos kb query my_docs_kb "recent breakthroughs in quantum computing"

# Search with metadata filtering and limit results
kleos kb query product_reviews_kb "positive feedback on model X" \
  --metadata-filter '{"rating":{"$gte": 4}, "verified_purchase":true}' \
  --limit 5

The --metadata-filter accepts a JSON string, enabling powerful, targeted queries by combining vector search with traditional attribute filtering.

3. AI Agents - Your Intelligent Assistants (`kleos kb create-agent`, `kleos kb query-agent`)

MindsDB allows you to create AI Agents that combine the power of Large Language Models (LLMs) with the contextual knowledge stored in your KBs and databases. Kleos makes agent creation and interaction straightforward.

a. Creating Agents (kleos kb create-agent)

Define an agent, link it to one or more KBs, and specify the LLM it should use:

# Create an agent using Google's Gemini model, connected to 'product_faq_kb'
kleos kb create-agent product_support_agent 
  --model-name gemini-2.0-flash 
  --google-api-key "GOOGLE_API_KEY"
  --include-knowledge-bases "product_faq_kb" 
  --prompt-template "You are a helpful support agent. Answer the user's question based on the provided documents: {{question}}. Context: {{context}}"

You can also include regular database tables for additional context and pass other parameters like temperature or API keys.

b. Querying Agents (kleos kb query-agent)

Once created, interact with your agent using natural language:

kleos kb query-agent product_support_agent "What is the warranty period for model X?"

The agent will leverage its LLM and the content from product_faq_kb to provide an answer.

4. AI Models / Generative AI Tables (`kleos ai ...`)

Beyond KBs and Agents, Kleos helps you manage MindsDB's powerful AI Models (often referred to as Generative AI Tables). These models are trained on your data using SQL and can perform a variety of tasks.

a. Creating AI Models from Data (kleos ai create-model)

Train a model directly from a SQL query. For example, to create a model that summarizes HackerNews story titles:

kleos ai create-model title_summarizer
  --select-data-query "SELECT title AS original_title FROM my_hackernews_data.stories WHERE score > 50 LIMIT 100"
  --predict-column title_summary
  --engine google
  --prompt-template "Generate a very short, catchy summary for this news title: {{original_title}}" 
  --param api_key YOUR_GOOGLE_API_KEY
  --param model_name gemini-2.0-flash

This creates a queryable title_summarizer model. You can then select from it, providing new titles to get summaries. Kleos supports listing, describing, refreshing, and dropping these models too.

5. Automation with MindsDB Jobs (`kleos job ...`)

Repetitive tasks like data ingestion or model retraining can be automated using MindsDB Jobs. Kleos provides commands to manage these jobs.

a. Creating Jobs (kleos job create, kleos job update-hn-refresh)

For instance, to create a job that updates your HackerNews data daily:

kleos job update-hn-refresh daily_hn_data_update --schedule "EVERY 1 day at 02:00"

Or, create a custom job with any SQL statements:

kleos job create nightly_kb_update
  "INSERT INTO my_kb SELECT new_text, new_metadata FROM new_data_source LATEST;"
  --schedule "EVERY 1 day at 03:00"

Kleos also allows you to list, check the status/history of, and drop jobs, giving you full control over your automated workflows. This combination aims to make the Kleos not just powerful but also pleasant to use.

Why This Matters: The Power of In-Database AI & Kleos's Role

The ability to perform complex AI/ML tasks directly within your database using SQL, as enabled by MindsDB, is a game-changer. It democratizes AI by lowering the barrier to entry and streamlines workflows by keeping data and intelligence in one place.

Kleos CLI aims to be a key enabler in this ecosystem by providing:

Accessibility: A user-friendly command-line tool that makes MindsDB's advanced features easy to discover and use.
Productivity: Simplifying common tasks like KB management, agent creation, and job automation.
Experimentation: Facilitating local development and rapid prototyping with tools like the provided Docker Compose setup.

Whether you're building RAG (Retrieval Augmented Generation) applications, AI saas application, or AI agents workflows, creating custom chatbots, automating data insights, or simply exploring the potential of in-database AI, Kleos and MindsDB offer a powerful combination.

Nearly at End

Kleos CLI is an open-source project, and your contributions and feedback are highly welcome!

GitHub Repository:
yashksaini-coder / Kleos

Every system has its `telos´ — its final cause. This CLI fulfills the purpose of MindsDB's Knowledge Base: to seek, structure, and serve insight through intelligent agents.
Kleos CLI - Your MindsDB Knowledge Base Toolkit

Kleos provides a powerful and interactive, Command Line Interface (CLI) for interacting with MindsDB, with a special focus on its Knowledge Base features and AI Agent integration. It also includes a suite of scripts for performance benchmarking, stress testing, and evaluating MindsDB's reranking capabilities.
- To learn more about the commands and advanced usage, please refer to the COMMANDS_REFERENCE.md file.
- For a quick overview of the most common commands and their usage, see the Quick-examples.md file.
🎥 Project Showcase

Demo Video DEV Post

Features
- Enhanced CLI (kleos):
  
  Interactive mode for a shell-like experience (run kleos then type commands).
  
  Manage MindsDB datasources (e.g., kleos setup hackernews).
  
  Create, index, and query Knowledge Bases (e.g., kleos kb create ..., kleos kb query ...).
  
  Ingest data into KBs (e.g., kleos kb ingest ...).
  
  Create and query AI Agents linked to…
View on GitHub
Try it out: You can clone the repo and install it locally on your machine using pip install . You can install the cli by running the command pip install Kleos. While writing this article, this feature is in work and will be available very soon.
Explore Knowledge Base Dive deeper into what Knowledge Base can offer.

At present, the kleos depends on mindsdb docker-extension & gemini for llm proider, but journey of Kleos is just beginning. Future enhancements could include even richer interactive experiences, more detailed reporting outputs, and support for a wider array of MindsDB's evolving features.

Thanks for sticking to the end of article. This project took a lot fo heart, research, and all-nighter and late nights snacks too.

Donate if you wish to support 💗: yashksaini-coder - GitHub and ⭐ the Kleos project. See you all next time.

Upvote Kleos and support if you haven't already.

What does not Giving up get you ? Prime example

Yash Kumar Saini — Sat, 21 Jun 2025 20:32:21 +0000

Chirag Aggarwal

Jun 21 '25

From student to full-time Platform Engineer at Appwrite

#career

Comments 15

4 min read

How I built a AI Agent server

Yash Kumar Saini — Sun, 20 Apr 2025 18:40:54 +0000

Hi everyone, hope you are all doing well. Today I am going to share how I built an AI agent server and deployed it as API. I'm pretty sure, many of you know by now, what an AI agent is and how much popular they have become.

This is Hack Agno an AI agent which is deployed as an API service.

With the integrations and applications being developed, I also wanted to create such an application. The inspiration came from Youtube when I was, searching for resource materials to learn Agents. later on I saw a clickbait, where a guy once developed and created an Agent deployed as API.

Just around that time, the opportunity presented itself, and then I was already working on building the server. Since this was my first solid AI agent project. I wanted to build with a tech stack that I have worked with before and one I had been working with a long time. So it was Python and FastAPI

The hackathon was focused on building AI agents with any framework so with Python in mind, I opted to use a light-weight AI framework. which is, Agno a lightweight library for building Agents with memory, knowledge, tools and reasoning.

You can use Agno to build Reasoning Agents, Multimodal Agents, Teams of Agents and Agentic Workflows. Agno also provides a beautiful UI to chat with your Agents and tools to monitor and evaluate their performance.

I created different API routes, that mostly are powered by AI agents. In this project, there are two AI agents, which basically communicates with FastAPI backend, then the response is generated and the output is then show at the client side.

I also had free time so I decided to give it a retro terminal like UI, and am really satisfied with it.
Check out the Original server Here
For those who want to see this in action can go to

By building this project is taught me a lot of things, also showed me that we can use AI agent in many different themes and setups to automate, improve and make apps way more better and interactive.

If you like this project You can vote for it. Login to the Quira and vote on the Hack Agent Server

Follow for more such content.

GitHub | Linkedin | Portfolio | Youtube

Automate Discord Messages

Yash Kumar Saini — Sat, 29 Mar 2025 10:40:03 +0000

Hi 👋 DEVs, in order to get my perspective and objectives of why I did this project and How I built this weekend project, let me first tell you about myself.

yashksaini-coder (Yash Kumar Saini) · GitHub

Building 🌐 Skynet from Terminator 🤖 . yashksaini-coder has 155 repositories available. Follow their code on GitHub.

github.com

I'm a person who is passionate for building things my way like with retro, simple, and one that can allow me to skip or automate basic tasks. I started my Open Source journey over 3 years ago, At first I struggled with the basic commits, issues and PR stuff. However I loved the idea of all the open source projects, ideas, projects widely available for learn and use.

I discovered Discord and there I joined many communities where i met and interacted with many Developers, each working on some project either their own or someone's else.

✨ Why I Built this project ?

Now, recently I was introduced to fun gaming bot widely famous and known as OWO where users can hunt, battle, gamble, complete quests and build their team to battle with among players. The main idea is to hunt and gather resources & animals to build and strengthen your team. Complete quests & gamble

But as I am lazy I wasn't motivated enough to do this manually by typing. There I thought of why not automate this by using a python program to locally run a bot and write messages on certain channel using their ID. Then I started researching on web, how to use discord API and send messages through it with proper authorized token.

I wanted to send more than one message with proper intervals so that my activity wouldn't be flagged as suspicious or malicious bot. So came up with the idea to set a custom minimum & maximum intervals of each message. Instead of using hard coded in lines, Generally I used to approach of using simple JSON (JavaScript Object Notation) implementation, for setting up user_tokem, channel_ID and messages.

{
  "Config": [
    {
      "token": "your_token_here",
      "channel_id": "your_channel_id_here",
      "messages": [
        {
          "content": "Hello, this is a test message!",
          "min_interval": 5,
          "max_interval": 10
        },
        {
          "content": "This is another message.",
          "min_interval": 10,
          "max_interval": 15
        }
      ]
    }
  ]
}

😉 How I built this project ?

I built this project during the weekend and I wanted to make it feel like a simple Retro Terminal tools like bagels, btop I wrote the code to use rich and colorama to higlight the texts with proper color palette. Then later on decided to use Looping to send messages using Discord API with POST request.

Oh! Almost forgot to mention this. Recently I started building all my general projects of Python using,

UV

It's nn extremely fast package and project manager, written in Rust. Much better to use and better then all the other alternative tools pip, pip-tools, pipx, poetry, pyenv, twine, virtualenv,

And for the program to feel more like a Terminal tool I used

Rich
Typer

⚡Key Features

Automated Message Sending: The bot sends messages to a specified Discord channel at random intervals within a defined range.
User-Friendly CLI Interface: Uses Typer and Rich for an interactive and visually appealing command-line experience.
JSON-Based Configuration: Stores user settings, including the Discord bot token, channel ID, and message configurations.
Multi-Threaded Execution: Each message runs in its own thread, ensuring asynchronous delivery without delays.
Graceful Shutdown Handling: Supports interruption via Ctrl+C while safely stopping all active threads.
Logging & Error Handling: Implements structured logging using rich.logging and handles errors gracefully.

✨ Workflow Overview

The proper workflow that the script follows to allow users to automate messages can be visualized as follows:-

1. Configuration Setup

On the first run, the script checks for config.json.
If missing, it prompts the user to enter:
- Discord bot token
- Channel ID
Saves this data in config.json.

2. Adding Messages

Users can add messages to be sent at specific intervals.
Each message includes:
- Message content
- Minimum and maximum interval (in seconds)
Messages are stored in config.json.

3. Starting the Bot

Loads settings from config.json.
Spawns a separate thread for each message.
Sends messages at random intervals.
Logs each sent message with timestamps.

4. Shutting Down

When interrupted (Ctrl+C), the bot stops all threads.
Ensures a graceful shutdown without abrupt termination.

🤖 Project Repository

Although the project didn't took much time on coding phase, the research and ideation phase took almost a day, before I finalized a proper structure, design and proper logic to implement to build this project.

yashksaini-coder / Auto-MSG-Discord

An Automating python script to send message to a channel on behalf of a user with specific messages & their assigned intervals.

Auto message 🤖

An Automating python script to send message to a channel on behalf of a user with specific messages & their assigned intervals.

Caution

This bot is for educational purposes only. Use it responsibly and in accordance with Discord's Terms of Service Do not use it for spamming or any malicious activities.

Usage 🚀

Clone the repository:

git clone https://github.com/yashksaini-coder/auto-msg-discord
cd auto-msg-discord

Create and activate virtual environment:

python -m venv venv
source venv/bin/activate  # On Windows, use `venv\Scripts\activate`

Install dependencies:

pip install -r requirements.txt  # Or use `uv pip install` if available

Run the bot:

python bot.py

Configuration ⚙️

The configuration is done in the config.json file.

Note: Make sure to configure config.json before running the bot.

{
  "Config": [
    {
      "token": "your_token_here"
      "channel_id": "your_channel_id_here",
      "messages": [
        {
          "content": "Hello, this is a test message!"

…

View on GitHub

Here's 🎞️ demo of me testing and running the bot live to automate sending messages on a particular channel on my own Discord server.

🌐Conclusion

This project was very fun and challenging. Instead of using high use-case Python libraries, I used simple logic with very simple libraries to automate and send messages to a widely used application and the best part was to see that the code was working as it was intended and designed to do. Fulfilling and working properly, with a seamless, minimal, sleek UI design.

The Friendly Future: How AI Makes Life Easier and Safer for Everyone

Yash Kumar Saini — Thu, 06 Mar 2025 06:08:49 +0000

Dear Reader,

Hi there! I’m writing this letter to share some fun and simple ideas about how latest technology, especially the AI (Artificial Intelligence) is changing our world in different ways. Imagine having a little helper that’s as clever as your favorite storybook character, always ready to lend a hand and make your day brighter!

What Is AI and How Does It Work?

Think of AI as a smart buddy living inside our computers and gadgets. It’s like a magic crayon that learns how to draw better pictures with every stroke. Just as you learn by playing, AI learns by looking at lots of examples and practicing over and over. It can help answer questions, find the fastest way home, or even suggest a yummy new snack recipe. In a way, AI is like a helpful friend who grows smarter with every adventure we share!

How Technology Affects Us

At Home: Imagine coming home to a cozy place where smart devices greet you like old friends. Lights that know when to turn on, speakers that play your favorite lullabies, and even a refrigerator that reminds you when it's time for a snack. These clever helpers make our everyday routines easier and more fun.
At School and Work: At school, computers and tablets turn learning into exciting games. Math becomes a puzzle to solve and reading transforms into a treasure hunt. At work, smart technology helps adults solve problems faster—almost like having a team of superheroes working together!
In Our Communities: Technology connects us no matter where we are. We can easily share pictures and stories with our loved ones who are far away, join online games with friends, or even attend fun virtual events. It’s like having a giant playground that stretches all around the world!
For Our Health and Well-being: Doctors and nurses use smart tools to keep us healthy. Imagine a friendly robot helping your doctor check your heartbeat or reminding you to drink water. These gadgets help keep us safe and happy, much like a caring guardian always by our side.

How Technology Is Used in Everyday Life

Learning and Creativity: Technology isn’t just about work—it’s a gateway to creativity! Kids can paint digital pictures, build stories with interactive apps, and even make music with simple tools. It makes learning as playful as a game and creativity as endless as your imagination.
Helping Hands Everywhere: In our busy world, smart technology finds its way into nearly every part of our lives. It helps farmers water their fields just when the plants need it, guides cars along safe roads, and even assists scientists in exploring the mysteries of space. Every new gadget is like a tiny magic tool that helps us solve big puzzles.
Connecting People: Social media and video chats let us see the smiles of friends and family even if they are far away. It’s like having a giant digital hug that makes everyone feel close, no matter how far apart we might be.

Safety Guidelines for a Tech-Filled World

Even though technology brings lots of fun and help, it’s important to use it wisely—just like riding a bicycle with a helmet!

Keep Your Information Safe: Just as you wouldn’t share your secret hideout with strangers, it’s smart not to share personal details like your home address or special passwords online. Always ask an adult if you’re unsure.
Use Friendly and Respectful Tools: Remember to be kind online. Technology is a tool for sharing fun ideas and happy moments. Using it to help each other learn and grow is like building a wonderful digital playground where everyone can join in safely.
Ask for Help When Needed: Sometimes, even smart technology can be confusing. If you ever feel lost in the digital world or see something that makes you uncomfortable, talk to a grown-up. They are like the wise guardians who help keep our digital playground safe.
Regular Updates and Smart Settings: Just as you put on a raincoat when it’s cloudy, keeping your devices updated with the latest safety features protects them from sneaky bugs and glitches. Ask an adult to help set up safe screens and privacy rules—these are like magical shields that keep bad things away.

Thank you for reading my letter. I hope you’re as excited as I am about our future with technology. With growing technology it is necessary to know and learn about new things, AI can be applied to every field of domain in the civilization and help shape our future to a better end.

First look into Daytona + TypeScript Integration

Yash Kumar Saini — Sat, 14 Dec 2024 17:36:22 +0000

Introduction

Daytona is a very good and very simple to use open source Development environment manager, that can be very useful for building a proper development workflow. It ensures development environments remain consistent and predictable throughout out the dev lifecycle.

How it helped me:

When I started contributing to open source very seriously past this year and during the Hacktoberfest'24, I noticed that a lot of time and resources is spent during the setup of the projects I want to contribute to. In order to contribute, I first forked the project, cloned it locally open it on vscode, install dependencies and finally run it locally on my system.

This took a lot of my time and resources initially. At that time I did wonder if there could be a way to skip this initial process or do it more quickly.

Fortunately I learned about Daytona and its capabilities to quickly get started with coding, and skipping all those tedious tasks for Development environment setup.

I used Daytona for my relay-chat-backend, a WebSocket chat application written in Typescript/NodeJS setup. The experience was very good, every step was smooth run and properly executed. Encountered no problems.

Here's why you should also use Daytona:

Works with every version control

Works with Any IDE of your choice

Works anywhere with these integrations

Advantages:

The best thing I experienced about Daytona is that you get a very cool & interactive CLI with commands to easily get started with the development environment.

The entire environment is created by using a simple command:-

daytona create <REPO URL>

Getting Started

Install Daytona using their Installation guide.
I used Daytona on Windows so you will need to install it using a powershell script. Here's the script code,

$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.47/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;

Git-Providers Daytona allows its users to connect additional git providers very easily.

daytona git-providers add

NOTE:- You can add many more git provider services

Providers You can easily create and manage your cloud environments very easily. Different cloud providers are Azure, AWS, GCP, localhost, Docker (both local or remote).

NOTE:- For extra options it first needs to install the providers SDK.

daytona provider install

Add Dev Container Once you are completed, add a Devcontainer.json inside your project like this .devcontainer/devcontainer.json.

If you are having trouble setup the devcontainer for your project, you can use the Devcontainer AI to set it up for you very easily, by just copy-paste your repo link. It will automatically create the devcontainer.json config file.

Here's my relay-chat-backend devcontainer.json config file:-

{
  "name": "WebSocket Chat Application",
  "image": "mcr.microsoft.com/devcontainers/typescript-node:20",
  "forwardPorts": [
    3000
  ],
  "customizations": {
    "vscode": {
      "settings": {
        "typescript.tsdk": "/usr/local/lib/node_modules/typescript/lib",
        "editor.formatOnSave": true
      },
      "extensions": [
        "esbenp.prettier-vscode",
        "dbaeumer.vscode-eslint"
      ]
    }
  },
  "postCreateCommand": "npm install"
}

Create your project workspace

daytona create https://github.com/yashksaini-coder/relay-chat-backend

Final Step

To start the application, simple run this command in the terminal

npm run dev

Few Key takeaways:

Boosting my overall productivity, by automating the tedious dev environment initial setup and management, hence optimizing the overall efficiency of my workflow.
Providing security, by control access and comprehensive dependency management, & safeguarding the projects & sensitive information from threats.
It also supports scalability when I tested it on the full stack chat application (both frontend + backend) of my application. Easy re-modification and setup.

Conclusion

I really liked Daytona, it is very easy to use, can run on different machines, setting up & managing the Dev environments is very quick and smooth going. Try it today, I bet you will have a very good experience with it.

If you like this blog, kindly show support to me Project & to the Daytona.

Star Relay-chat-backend

Star Daytona

[Boost]

Yash Kumar Saini — Thu, 28 Nov 2024 14:30:34 +0000

Chaoming Li

Nov 26 '24

🌟Open-source SaaS Starter: React + Firebase + Stripe + i18n

#react #stripe #opensource #saas

Comments 17

2 min read

RAG Chatbot

Yash Kumar Saini — Wed, 20 Nov 2024 16:05:28 +0000

🌟 Exciting Times: Sharing My Latest Project Adventure!

Hey there, contributors and tech enthusiasts! 👋

After being caught up in a whirlwind of activities 🌪️, I almost forgot I had an account here! But guess what? I'm back with something exciting to share. 🎉

🌱 Inspiration Strikes!

Recently, while exploring resources to level up my Flask skills, I stumbled upon an absolute gem 💎 thanks to the courtesy of an amazing developer, @komsenapati.

✨ Introducing: A fantastic Flask project starter template!

It comes with proper login and register routes—just what I needed to kick-start a new project. 🚀

Here's the link to the Flask Minimal Template. Trust me, it's worth bookmarking! 🔖

🤖 Building a RAG-PDF Chatbot

Fueled by this resource and brimming with curiosity, I ventured into creating something I’m really proud of:

💡 A Multi-PDF RAG-Based Chatbot

This chatbot leverages cutting-edge Gemini and Groq AI services to provide intelligent responses. 📄💬 It can read and process multiple PDFs—perfect for those who work with document-heavy tasks. 📚✨

Here’s a sneak peek 👀:

Demo Video

🔗 Check It Out

I’ve open-sourced the project so others can learn, contribute, and improve upon it!

🔗 Repo Link: RAG-PDF Chatbot

💬 Why Contribute?

Here’s why you should join hands and contribute:

🚀 Learn: Deep dive into integrating AI services like Gemini & Groq.
🤝 Collaborate: Work with a vibrant community of developers.
🔧 Build: Add features like support for more file formats or better NLP models.

Whether you’re a Flask fan, an AI enthusiast 🤖, or just someone looking for a cool project to contribute to, this one’s for you!

🔥 What's Next?

I’m planning to:

Add support for real-time queries on live PDFs.
Improve UI/UX for a smoother user experience. 🎨
Incorporate more AI models for multilingual support. 🌍
Make this more Enhanced with adding links of articles to converse with

Let me know your thoughts in the comments 💬 or, better yet, submit a pull request! 💻✨ & let’s make this project a game-changer! 🌟

PS: Huge shoutout to the open-source community for inspiring me to keep learning and building. 🛠️💡

DEV Community: Yash Kumar Saini

Turning Weekly GitHub Activity Into Blog Posts on Notion + DEV.to

What I Built

What it actually does

Key features

Architecture

Architecture Deep-Dive

Why 3 agents, not 1?

Harvest: deterministic data, zero LLM

Narrate: LLM with a fallback chain

Publish: Notion planner + DEV.to draft

How I Used Notion MCP

1. Notion MCP Server via @mastra/mcp

2. Direct tools + MCP tools merged

3. The Markdown Content API (the game changer)

4. Rate limiting

Lessons Learned

Rate limits are the real boss

Structured output is slower than you'd think

Gemini model musical chairs

The Zod conflict that broke everything

Direct API calls beat agent reasoning for deterministic work

Simulating P2P Attacks and Teaching AI to Resume Sessions

TL;DR

WHAT I BUILT

PULL REQUESTS

CODE REVIEWS

TECH STACK

WHAT'S NEXT

Beyond the Panic: Hardening the Rust SDK

TL;DR

The Work: Velocity in the Engine Room

p2pCalc & AgentPay

DevNotion & The Developer Environment

The Pull Requests: The Safety Initiative

The Conversations: Setting the Standard

The Reviews: Raising the Bar

The Craft: A Polyglot Reality

The Horizon

I Built a TUI That Makes Rust Code Inspection Feel Like Magic ✨

The "Why Did I Build This?" Moment

What I Built

📦 Deep Code Analysis

🔍 Intelligent Search

📋 Dependency Inspector

🎨 Beautiful Themes

⚡ Smooth Animations

Demo

Quick Start

Sample Usage

My Experience with GitHub Copilot CLI

🎯 How Copilot Saved My Sanity

1. Wrestling with the syn Crate

2. Making the TUI Not Look Like Garbage

3. Making Search Feel Snappy

4. Parsing Cargo.toml Without Crying

5. Fetching Live Crate Info

6. Cross-Platform Path Hell

7. Making Animations Not Suck

8. Integrating Copilot within itself

The Stuff That Almost Broke Me

Challenge 1: Not Freezing the Terminal When Parsing Big Projects

Challenge 2: Making Search Feel Instant (Even When It's Not)

Challenge 3: GitHub Rate Limits Are Real

Challenge 4: Scrollable Content That Doesn't Suck

Why You Might Actually Want to Use This

🚀 It's Fast (Like, Really Fast)

🎨 It Doesn't Look Like Hot Garbage

🔧 Actually Designed for Terminal Use

📚 It Actually Understands Rust

How I Actually Use This Thing

Before Oracle:

With Oracle:

Installation & Usage

Install

Usage

What's Next (If People Actually Use This)

Why Rust?

Lessons Learned

1. TUI State Management is Hard

1. Notion MCP Server via `@mastra/mcp`

1. Wrestling with the `syn` Crate

1. Seamless Setup (`kleos setup`)

2. Knowledge Bases (KBs) - The Heart of Kleos (`kleos kb ...`)

3. AI Agents - Your Intelligent Assistants (`kleos kb create-agent`, `kleos kb query-agent`)

4. AI Models / Generative AI Tables (`kleos ai ...`)

5. Automation with MindsDB Jobs (`kleos job ...`)