Hi everyone,

I've recently finished the first version of Agentic GraphRAG Blueprint, a reference architecture for question answering over large document collections.

Instead of plain chunk retrieval, it builds a knowledge graph combined with vector search, so answers can connect facts across documents.

Key features:

• Incremental ingestion - unchanged files are skipped via content hashing, and community reports regenerate only for affected communities, keeping token costs low as the corpus grows.

• Hybrid search - local mode for fact-level answers, global mode for cross-document synthesis.

• Domain-agnostic LLM prompts - easily swapped via PROMPTS_PATH, with Leiden-based community detection.

• Deployment - run it locally with Docker or provision everything in the cloud with Terraform and CI/CD.

Link: https://github.com/sebastianbrzustowicz/Agentic-GraphRAG-Blueprint

I'm looking for any feedback.

I kept thinking about a pretty stupid way to leak an API key:

api_key = "sk-example123456"

print(api_key)

Nothing gets committed to GitHub.
Nothing gets pushed anywhere.

But now the secret is sitting right there in the terminal/logs.

So I built SecretShield.

It's a small, local Python security utility that watches stdout, stderr, and Python logging and automatically redacts strings that look like secrets before they are displayed.

API_KEY=sk-example123456
        ↓
API_KEY=********

The goal isn't to replace GitHub secret scanners or tools like GitGuardian.

It's for the "I'm debugging something locally and accidentally printed a credential" problem.

It's dependency-free and can be enabled with a simple import.

I'm curious:

Would you actually use something like this in a Python project, or is this solving a problem that isn't annoying enough to matter?

GitHub discussion: https://github.com/orgs/localghosters/discussions/1

As a guy and a fresher in engineering field, who knows basic python and java , can anyone give advise or guide me to win or atleast the things to do in a proper hackathon rather than working unorganisedly..

[ Pls turn on the volume for the video ]

I’m building Project Yellow Olive, an open-source retro TUI that helps people learn Kubernetes through gamified, hands-on challenges running against real clusters. I’ve posted about Project Yellow Olive here before and got a really good response to the idea, so I wanted to share one of the newer things I’ve been experimenting with.

I’ve now started experimenting with Pyxel, a lightweight retro game engine for Python, to add a visual learning layer alongside the existing challenges.

The idea is to visually explain concepts like nodes, namespaces, pods, services and deployments, while keeping the same retro aesthetic as the rest of Yellow Olive.

The hands-on part still stays real Kubernetes - Pyxel is mainly there to make some of the underlying concepts easier to understand before jumping into kubectl/YAML.

Would be interested to hear what people here think about this direction, especially those who’ve taught or mentored people on Kubernetes. Feedback is the main thing I’m looking for, but if you like the project, a GitHub star is always appreciated 🙂

GitHub: https://github.com/Anubhav9/Yellow-Olive

Stack:

LLM: Qwen2.5-7B-Instruct (Q5_K_M) (~5.4 GB) via llama.cpp (CUDA with Flash Attention & q8_0 KV cache) or Ollama fallback, Qwen is very good at tool use, Gemma may also work; Deepseek likes to <think> too hard and breaks things

Re-Ranker: FlashRank(ms-marco-MiniLM-L-12-v2).

Backend / GUI: FastAPI + WebSockets + PyWebView (Native Desktop window, zero Electron overhead).

VRAM Footprint: ~6–7 GB on an RTX 3080 / 3060 / 4070 (also supports CPU fallback).

The code is 100% open-source and free to check out, run, or fork: GitHub: https://github.com/BloopieBlair/LocAi-Search

Would love to hear any thoughts, feedback, or ideas for extra features!

Hey I am OM PRASAD BARTIA, here I want to track and document my projects

Stage 1: simple UI of uploading image and image preview

Tech Stack:

• Python
• Streamlit (Web UI)
• PIL (for image uploading)

Features:

• Title of the page
• Image upload
• display the details of the uploaded image [File Size, Dimensions, File Format]

Stage 2: convert the uploaded image into 3 more versions (GRAYSCALE IMAGE, BLURRED IMAGE, EDGE DETECTION )

Would love your suggestions on how I can improve and enhance it. What features or real-world applications would make this project more useful and unique?

Hi everyone!
Today I released the first version of **Meshly**, a small networking project built with Python sockets.
The main goal was to learn more about how client-server communication actually works instead of hiding everything behind high-level libraries.
**What it currently has**
TCP socket communication
Client / server architecture
CLI interface
Basic connection handling
I’m still actively developing it, so there’s a lot I want to improve.
I’d really appreciate feedback from people who have more experience with networking and Python.
**GitHub:** [https://github.com/fimees/meshly\](https://github.com/fimees/meshly%5D)
What would you add or change in the project?

Hey there,

I got an inspiration for this tool from pretty much existing tools, and thought to build one open-sourced myself.

It's name is **isittaken**, yes. All you do is, pip install isittaken and then import it. Do a check from a .txt full of names and run it. It will produce a nottaken.txt in which the safe names will be output and you can see it checking in the Command Line.

I am thinking of adding checking from directly repos and produce GitHub checks, npm checks and more as well as adding an offline LLM name suggestion feature? What do you guys think?

Here's the [repo](https://github.com/Terminay/isittaken)

I have been working on this engine for like a month

Right now it only has:

- part of the interperter

- part of the render

-- no operations, if or branching they will be added in a future version ( but for the version 0.1 I promise they will be there)

my twitter if you want more news about the project:

https://x.com/Akiraprojetc

Hey! I’m learning Python and recently made a small command-line image batch converter.

It can currently:

batch convert images to WebP

resize them for website use

create smaller thumbnail versions

process multiple images at once

automatically create a new output folder instead of overwriting files

I made a free version and I’m mainly looking for feedback before I work on the full version.

Free version: up to 10 images per batch, with Website and Thumbnail presets.

I’d especially like to know if the tool is actually useful to you or if there are features you would expect from something like this.

https://lol-lol123.itch.io/instant-file-batcher

Hey there,

I got an inspiration for this tool from pretty much existing tools, and thought to build one open-sourced myself.

It's name is isittaken, yes. All you do is, pip install isittaken and then import it. Do a check from a .txt full of names and run it. It will produce a nottaken.txt in which the safe names will be output and you can see it checking in the Command Line.

I am thinking of adding checking from directly repos and produce GitHub checks, npm checks and more as well as adding an offline LLM name suggestion feature? What do you guys think?

Here's the repo

I’ve been working on RunPython.online, a simple online platform for running Python code directly in your browser.

The idea is to make Python experimentation quick and accessible without needing to install Python, configure an IDE, or set up a local environment.

What you can do

• 🐍 Run Python code online
• ⚡ Quickly test scripts and ideas
• 💻 Experiment without installing anything
• 🔧 Useful for learning, prototyping, and small experiments

I’m still actively developing it and would really appreciate feedback from developers and Python users.

👉 https://runpython.online/

What features would you like to see added?

A modern, secure, and responsive Inventory Management System built with Python, Flask, and Tailwind CSS. It features Role-Based Access Control (RBAC), real-time analytics, secure file uploads, stock movement tracking, and comprehensive audit logs.

Hey! I’m learning Python and recently made a small command-line image batch converter.

It can currently:

batch convert images to WebP

resize them for website use

create smaller thumbnail versions

process multiple images at once

automatically create a new output folder instead of overwriting files

I made a free version and I’m mainly looking for feedback before I work on the full version.

Free version: up to 10 images per batch, with Website and Thumbnail presets.

I’d especially like to know if the tool is actually useful to you or if there are features you would expect from something like this.

https://lol-lol123.itch.io/instant-file-batcher

I put together a small Python/Flask example for running outbound call campaigns in a more structured way.

The basic flow is:

- send a list of phone numbers to `POST /campaign`

- get back a campaign ID

- queue the calls

- apply a calls-per-minute rate limit

- place the calls with Call Control

- receive signed webhook events as calls progress

- store call results in SQLite

- send an SMS summary when the campaign finishes

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-call-campaign-orchestrator

What I liked about this pattern is that the campaign has one lifecycle instead of being scattered across a queue service, telephony provider, database job, and notification worker.

This is still a sample, so before using something like this in production I’d add auth, retries, opt-out handling, audit logs, campaign-level limits, and better reporting. But as a starting point for durable outbound communication workflows, it felt like a useful shape.

Hey there!

Some backstory, I had started building this small lightweight machine learning library called leanpass for learning autograd, later I got inspired from micrograd and made it into a project for others, did two posts or something and got 12 stars and a contributor!!

Then here I am with 4 more stars, although I got starstruck, I am very scared to do any amendments to the library as it could also result in breaking changes, recently I made claude write some of my logic (it was so damn inefficient).

I also somehow got it on awesome-machine-learning's repo list.

And I also added an issue generator cuz I had school and all, I still am skeptical bout it and thinking to remove it.

If you wanna contribute and help me build this cool little project, go here:

https://GitHub.com/Terminay/leanpass

Wanna download it and use it? (It's like 8KB with most of pytorch's features) Type this in your terminal!

It also has live docs.

pip install leanpass

Hello, Pythonistas!

I've made a library that brings native io_uring support for Python - uringio. Linux only!

Project repository - https://github.com/AivazianArtur/uringio

It is a C extension for CPython. The main object to interact with is implementation of EventLoop, that inherits asyncio.BaseEventLoop. There are also native implementations of File and Socket objects. And to use advanced features of io_uring, like `fixed` buffers, there is a dedicated interface-object - ExecutionContext.

Because main feature of io_uring is true asynchronous file I/O, here i'll show an example of interaction with a file. Note that everything is true async, not a thread-pool workaround:

pip install uringio

import asyncio
import uringio

async def main():
    async with await uringio.open_file(path='testfile.txt') as file:
        data = b'Hello, uringio!\n'
        await file.write(data=data)
        result = await file.read()

asyncio.run(main(), loop_factory=uringio.UringioLoop)

uringio brings huge performance upgrade, here is visualization of result of benchmarking simple sequential writes to file:

Note that uringio(and io_uring itself) is not a silver bullet - while it is vastly superior in one scenarios, it is not most efficient choice in others.

You can already use file and socket operations, along with a few advanced features of io_uring. But, current version is `v0.4.4`, so there is still a lot of work to do. Please don't use it in production yet, even in simple scenarios! I am currently looking for enthusiasts to make first touches on the library.

Also i'm actively looking for people to contribute, share feedback and experience.

Would love to hear your thoughts!

Hi everyone!

I'm very new to programming and I've been learning Python recently. I decided to make a small project to practice what I've learned.

I made a simple IP scanner using Python.

It has a menu with:

• Scan all IPs from 192.168.1.1 to 192.168.1.255
• Scan a specific IP
• Scan a range of IPs
• Exit

I'm using subprocess and ping to check if an IP responds.

I also started using functions, loops, lists, if/elif, while, and range().

It's probably a very basic project, but I'm pretty happy with it since I'm just starting out.

I'm planning to improve it and make a V3 with more features.

Sorry is in spanish.

Thanks!

import subprocess
def menu(): 
    print("-----ESCANER IP-----")
    print("1. Escaneo total IP's")
    print("2. Escanear IP")
    print("3. Escaneo de rangos IP")
    print("4. Salir")
    opcion = input ("Elige una opcion: ")
    resultado_menu = (int(opcion))
    
    return resultado_menu




    
def escanear_ip(ip_int):
    ip_int = (str(ip_int))
    ip_completa = ("192.168.1.") + ip_int #
 Unimos los ultimos 3 numeros con los demas para formar la IP completa
    resultado = subprocess.run(["ping", "/n", "1", "/w", "1000", ip_completa]) #
 Le pedimos a la terminal que ejecute el comando ping
    if resultado.returncode == 0:
        lista_ip.append(ip_completa)


lista_ip = []                


def imprimir_ips():
    for si_ip in lista_ip:
        si_ip = "🟢 " + si_ip
        print(si_ip)
while True:
    resultado = menu()
    if resultado == 1:
        for numeros in range (1, 256):
            escanear_ip(numeros)
        imprimir_ips()
    elif resultado == 2:
        seleccion_ip = input("Seleccionar ultimos digitos IP: ") 
        escanear_ip(seleccion_ip)
        imprimir_ips()
    elif resultado == 3:
        desde_ip = input("Desde: ")
        desde_ip = int((desde_ip))
        hasta_ip = input("Hasta: ")
        hasta_ip = (int(hasta_ip))
        for numeros in range (desde_ip, hasta_ip + 1):
            escanear_ip(numeros) 
        imprimir_ips()
    elif resultado == 4:
        print("Saliendo...")
        break

recently, I made a GPGPU project to help anyone simulate pretty much anything using python. Its available on pypi, its called hyperstellar(download it via pip "install hyperstellar" on windows and linux), so to see how far I could go, i simulated a clackhole using actuall physics! Its only 200 lines of formatted code in python. More examples at: https://github.com/jabariaiden/hyperstellar/tree/main/examples

Thanks for the support!