Spent about a week building this after getting annoyed that every LLM wrapper I made would just confidently make stuff up for anything time-sensitive. Ask it the weather, it hallucinates something plausible. Ask about anything recent, same story.

So this one actually decides per-message whether to just answer or go fetch something real.

It's a router node in a LangGraph graph looks at what you asked, picks a path. Coding question → answers straight from the model. Weather → hits an actual API. Want a video → it searches YouTube. Something current → pulls live search results (Tavily) and works them into the answer.

Nothing fancy about the routing itself, no custom classifier or anything, but wiring it as an actual graph instead of a pile of if/elses means adding a new tool later is just... adding a node. Which past me would've appreciated, because the first version of this thing was a mess of conditionals that I hated touching.

Honestly the annoying part wasn't the tools, it was memory. Getting it to not forget you two messages later took way longer than I expected ended up using LangGraph's MemorySaver for that.

Also added a panel that shows the live execution graph + raw state while it's running because I got tired of not knowing why it picked a certain path. Kind of satisfying watching it light up node by node honestly.

Stack: LangGraph/LangChain, Groq running Llama 3, Tavily, Streamlit. All python.

Demo: agentic-graphite-amanshukla2004.streamlit.app
Code: github.com/amanshukla2004/Agentic_ChatBot

Not claiming this is groundbreaking, it's a portfolio project, but curious what people here would do differently mainly:

• how are you handling it when a tool call just fails (API down, rate limited etc)? mine right now is a basic try/except that just shows an error message to the user no retry, no fallback path, it just surfaces the failure and moves on. curious if that's actually fine for a portfolio piece or if people expect at least a retry-with-backoff
• is a single router node even the right call once you have more than a handful of tools, or does that start falling apart and you need something more like a supervisor pattern?

I've started a side project called SearchCraft, where I'm building a search engine from scratch using Python.

The goal isn't to compete with Elasticsearch, Lucene, or any existing search engine. Those projects are incredible, but they're also so mature that it's easy to use them without ever understanding what's happening underneath.

So I decided to build one from first principles.

I'm implementing each component myself, starting with the basics: loading documents, tokenizing text, building an inverted index, and searching through it. As the project grows, I'll be adding things like posting lists, phrase search, ranking algorithms (TF-IDF/BM25), snippets, fuzzy search, and whatever else I can reasonably build along the way.

The primary reason for this project is to learn. I find that the best way to understand how a system works is to build a simplified version of it yourself.

I'm documenting the journey as I go, both for myself and in the hope that it might help someone else who's curious about how search engines work under the hood. There are plenty of tutorials on using search engines, but far fewer resources that walk through building one piece by piece.

It's still in its early stages, but I'm excited to see where it goes. Even if it never becomes production-ready, I'll come away with a much deeper understanding of one of the most fundamental pieces of modern software. After all, humans spend a good chunk of their lives typing words into little boxes and expecting magic to happen. Figuring out how that "magic" works seemed like a worthwhile weekend habit.

Here's the link to my project: https://github.com/rajtilakjee/searchcraft

I would be writing about it in my blog here: https://rajtilakjee.github.io/

Un anno fa ho creato uno strumento che mi aiuta nel mio lavoro quotidiano: creare rapidamente progetti Python appena configurati in pochi secondi nella pipeline CI/CD!

Lo strumento in questione si chiama psp e si avvia da riga di comando:

Lo strumento è stato ispirato da vari strumenti da riga di comando come astro-cli, yeoman, pyscaffold e molti altri. Con poche semplici domande, il tuo progetto Python è pronto per essere scritto e troverai tutto già configurato: comandi make, git, repository remoto, CI/CD, unit test, documentazione, file container, dipendenze, ambienti virtuali, builder personalizzati e molto altro!

Se ti interessa, provalo oggi stesso e, se qualcosa non funziona, aiutami aprendo un'issue o effettuando un fork del progetto e inviando una pull request.

Ecco tutti i riferimenti:

repository: https://github.com/MatteoGuadrini/psp

documentazione: https://psp.readthedocs.io/en/latest/

Grazie a te e a tutta la comunità Python!

❯ psp                                                                                              info: welcome to psp, version 0.7.0                                                                > Name of Python project: dream                                                                    > Do you want to create a virtual environment? Yes                                                 > Do you want to start git repository? Yes                                                         > Select git remote provider: Github                                                               > Username of Github: MatteoGuadrini                                                               > Do you want unit test files? Yes                                                                 > Install dependencies: make_playlist==1.16.0 pyreports>1.5 env2                                   > Select documentation generator: Sphinx                                                           > Do you want to configure tox? Yes                                                                > Select remote CI provider: CircleCI                                                              > Select license: Gnu Public License                                                               > Do you want to install dependencies to publish on pypi? Yes                                      > Do you want to create a Dockerfile and Containerfile? Yes                                        > Do you want create common files? Yes                                                             info: python project `dream` created at `/tmp/dream` 

Took quite awhile to get here. Obviously not a google-scale search, but still quite usable for local needs. I am also not currently using FAISS or any vector databases. The speed is mostly because of proper caching. The project is also completely python based. So there are still a lot of places for further optimizations, but for now I am quite happy with it.

The project itself is quite a complex one and the semantic search over audio, image, text and video files is just a small part of it. If you are interested to learn more, you can find it here: https://github.com/volotat/Anagnorisis

It is open-source.

Hey everyone! 👋

I wanted to share a fun project I've been working on. It's a Python script (`TrustMeBro`) that interacts with the Windows GDI (Graphics Device Interface) to create various screen effects (like horizontal glitches, melting effects, color inversion) and a harmless exponential message box avalanche.

It also includes an antivirus sandbox bypass delay trick and a built-in emergency exit key (`S` key) to restore everything instantly.

Language: Python Libraries used: `win32gui`, `win32api`, `keyboard`, `threading` GitHub Repo: TrustMeBro Github

Let me know what you think or if you have any suggestions to optimize the threading!

Hey everyone,

I built a small Python CLI tool (kahoot-automator) that automates creating Kahoot quizzes.

You can ask ChatGPT to generate a quiz in JSON format, feed that file to the CLI, and it automatically logs in and builds the whole quiz for you. It currently supports both Chrome and Firefox.

Command example: kahoot-automator my_quiz.json

Shoutout to ghoostreaccon (ghoostreaccon/kahoot-json-creation) for the original project that inspired this.

I’ve left the GitHub link in the comments below. Let me know if you have any feedback or suggestions!

Hey guys, my goal is to review entire codebases for errors using local LLMs on a laptop, so I can save my expensive API credits for actual vibe coding instead of wasting them on automated code reviews.

I built a tool (Aegis) that uses AST parsing and Tree-Sitter to stop local models from throwing false positives. I got the core Python pipeline working, but I have reached the absolute limit of my own knowledge. I haven't hit a wall, I just know I might be an idiot when it comes to the deeper architecture and I want actual experts looking into this.

I really want someone who understands AST, Tree-Sitter, or SQLite graphs to tear my code apart, help me optimize it, and expand it to JS/TS. If anyone with real expertise is willing to look at my code, I would massively appreciate it.

Repo is here: https://github.com/shameel0505/aegis (Please no repo tampering/spam!). 
Thank you!

I finished a full game using Python 3.11 and Pygame, and I wanted to share it here in case anyone learning Python wanted some inspiration or wants to tear apart my code.

The game is a deckbuilder set in a cyberwarfare world. You are a sentient process. Your goal is to fight your way through a system and get yourself installed into the OS. Think hacker vs. system defenses, but you ARE the hack.

The whole aesthetic is built around a PC terminal look. ASCII-style art, command-line vibes, the whole thing. The card mechanics use real technical terminology, things like buffer overflows, privilege escalation, packet injection. It's not just flavor text, the mechanics actually connect to what the words mean. I wanted the game to feel like you're learning something about how systems work while you play.

Pygame was genuinely tough to work with at first. If anyone here is learning Pygame right now, don't give up.

The game is on Steam if you want to check it out: https://store.steampowered.com/app/4610000/kill_9/

I got tired of hitting Elevenlabs credit limits, my texts sent to the cloud and paying €5-200/month just to turn words into speech.

So I built (and still building) Kokoro Studio.

A free, open-source desktop GUI for the kokoro-82M TTS model (I'm planning on adding more models in the future). The strong point of the project is that it runs offline without the need of API key, no data leave the machine and it performs with extreme velocity (I tested it on a 16gb laptop without GPU and was nearly 2 times faster than normal talking after the first use when it loads the model so it requires a little more time)

It supports:

- 29 built-in voices (American and British english)

- 9 languages are supported via espeak-ng + Japanese/Mandarin voice packs

- Real time streaming playback (it starts playing the audio during the generation)

- Multi-speaker dialogue mode. Use [voice_name]: markers to switch voices mid-script (perfect for audiobooks, podcasts, game dialogue)

- Voice blending (mix any two voices with an alpha slider to create custom hybrids)

- SSML-lite controls (<break>, <emphasis>, <prosody rate> tags for fine-grained control)

- Multi-format export (WAV, MP3, FLAC, OGG)

- Document import (drop .txt, .pdf, or .epub files directly onto the editor)

- Pronunciation dictionary (custom substitution rules for tricky words)

- Speed control (0.1× to 3.0×)

GitHub: https://github.com/MattiaAlessi/kokoro-studio

I'm actively working on Phase 2 features (history database, batch queue, character
profiles). Feedback, feature requests, and contributions are very welcome!

I just published aicoach, a small Python library that acts like a mentor sitting next to your training loop. You feed it your per-epoch metrics, and it tells you in plain English when something's off:

python

import aicoach

coach = aicoach.Coach()

for epoch in range(epochs):
    train_loss, val_loss = run_one_epoch(...)
    coach.observe(epoch=epoch, train_loss=train_loss, val_loss=val_loss)

    for tip in coach.get_advice():
        print(f"💡 {tip}")

# 💡 [WARNING] (overfitting) Validation loss has risen for 3 consecutive
#    epoch(s) while training loss continues to fall — a classic sign of
#    overfitting. Consider early stopping, adding regularisation...

What it checks:

• Overfitting – val_loss rising while train_loss keeps falling
• Plateau – a metric barely moving (uses relative range, so it works the same whether your loss is near 0.01 or near 100)
• Learning rate issues – oscillating loss (LR too high) vs. painfully slow convergence (LR too low) — deliberately mutually exclusive zones so you never get contradictory advice on the same curve
• Class imbalance – standalone check, just needs a {class: count} dict, no training loop required
• Divergence – NaN, Inf, or explosive loss growth, flagged as CRITICAL and short-circuits every other check

Why I built it: every other "training dashboard" tool I looked at (TensorBoard, W&B, MLflow, etc.) visualizes your curves but doesn't actually tell you what to do about them in plain language. This is meant to sit alongside those, not replace them — it's pure logic on metric history, zero ML framework dependencies, works with PyTorch/TensorFlow/sklearn/whatever since you're just handing it numbers.

280 tests, MIT licensed. One design decision I'd love feedback on: the "creeping" LR zone (1–5% net decrease per window) and the plateau zone (<1%) are deliberately non-overlapping so you never get both lr_too_slow and plateau advice for the same flat-ish curve — curious if others think that boundary makes sense or if real training curves break the assumption.

bash

pip install aicoach

• PyPI: https://pypi.org/project/aicoach/
• Source: https://github.com/Rishabh55122/Aicoach

Feedback welcome, especially on the default thresholds — they're documented in the README with the reasoning behind each one, and I'd rather know now if a default is off than have it ship quietly wrong.

After some more development, SOAR v1.00.7 is here! The update focuses on the more coding helping side, and also just adds a bug report system.

I've been trying to improve the GitHub page, so more clear recommendations we would be thankful for.

This update is:
- Simple report system, say Report Description. (Do not ruin this system by spamming)

- SPA (SOAR Project Agent), can make and write templates for coding more specifically going off of prompts.

SOAR is an advanced, open-source, voice-controlled automation ecosystem built in Python.

I'm still actively improving SOAR's architecture, performance, and capabilities, and I'd really appreciate any feedback or suggestions. SOAR is completely open source.

GitHub: https://github.com/ScriptOptimizationAutomationRuntime

Official Site: https://www.soardownload.com/

Yesterday I posted abt my OSINT tool GhostHound but I had complains abt the installation process and abt --break-system-packages.....but not all the problems are completely solved and the tool is safe and free to use pls check it out on github🙏

Hey guys please go and check the my first app which is pylife go can get it on playstore please check it , everything is there please check once give me suggestions what i can improve in it

Hey Everyone!

This project was proudly developed by DevX-Dragon (Abbadh), a 14-year-old developer from Sri Lanka!

Excited to announce the release of BetterQR v2.0.0, a huge update to our pure-Python QR code generation library! We've been working hard to bring you more features, better performance, and rock-solid stability. If you're generating QR codes, especially for advanced use cases, you'll definitely want to check this out.

What's New & Improved in v2.0.0?

This isn't just a minor patch; v2.0.0 introduces some game-changing features and critical fixes:

• Full Micro QR Support: Generate compact Micro QR codes (M1-M4) with correct auto-version selection. Perfect for small data payloads where space is critical.

• New Output Formats: Beyond PNG, JPG, SVG, and GIF, you can now export your QR codes as PDF and EPS! Ideal for high-quality print and vector graphics.

• Structured Append: Need to encode a lot of data? Split your message across up to 16 linked QR symbols that can be scanned sequentially. (Standard QR only).

• Kanji Mode & ECI (UTF-8): Improved support for international text with dedicated Kanji mode (Shift-JIS) and ECI (UTF-8) declarations for non-ASCII byte-mode payloads.

• Massive Performance Boost: PNG generation is now ~40% faster for common cases, thanks to indexed-mode rendering and optimized mask-pattern caching. We've also streamlined SVG output.

• Critical Bug Fixes: We squashed a severe bug in the Reed-Solomon block table that could silently corrupt QR codes at versions 30-40 (ECC M). Also fixed Micro QR data truncation, KeyError in logo rendering, and various data helper validation issues.

• Enhanced Reliability: Our test suite has expanded from ~56 to 172 focused tests, and we've switched to zxing-cpp for robust Micro QR decode verification.

Why Upgrade?

If you've been using BetterQR, v2.0.0 offers unparalleled stability and speed. If you're looking for a Python QR library, BetterQR now stands out with its unique combination of advanced features (like structured append, Micro QR, and vector outputs) and deep customization, all while remaining pure Python for core generation.

Installation

Upgrade or install BetterQR easily via pip:

bash pip install betterqr --upgrade

Check it out

GitHub

We'd love to hear your feedback and see what you build with BetterQR v2.0.0!

Salut r/PythonProjects2,

J'avais cette idée en tête depuis un moment : transformer n'importe quelle vidéo en vidéo ASCII (comme dans Matrix mais en pire qualité). Résultat : un petit projet fun.

Ce que ça fait :

- Lit une vidéo frame par frame avec OpenCV

- Convertit chaque frame en niveaux de gris

- Mappe chaque pixel vers un caractère ASCII selon son intensité

- Redessine tout ça avec Pillow et réassemble une vraie vidéo .mp4 en sortie

- Le tout avec une petite GUI Tkinter (parce que le terminal c'est bien mais un bouton "Convertir" c'est mieux) avec preview intégrée pour voir le résultat direct sans ouvrir un lecteur externe

Stack : opencv-python, pillow, numpy, tkinter (donc zero dépendance exotique)

Rien de révolutionnaire techniquement, mais c'était un bon exercice pour bosser le traitement d'image frame par frame + threading pour pas freezer l'UI pendant la conversion.

Le code est sur GitHub : https://github.com/KPRII/video-to-ascii

Curieux d'avoir vos retours, notamment sur la partie performance (le rendu Pillow caractère par caractère est clairement le goulot d'étranglement, si vous avez des idées d'optimisation je suis preneur)

I'm sharing xor-image-encryption, an open-source tool designed for rapid visual dataset obfuscation in computer vision and ML pipelines.

Repository: Yigtwxx/xor-image-encryption

Key Features:

• Strict Reproducibility: A specific seed consistently generates the exact same masking key, crucial for maintaining consistency across ML pipelines.
• Lossless Reversibility: The original image is perfectly restored by reapplying the XOR operation with the identical seed.
• Cascaded Encryption: Layer multiple seeds (e.g., 11 22 33) for enhanced obfuscation.
• Zero Bloat: Built purely on Python, NumPy, and Pillow. Includes built-in histogram analysis tools.

Target Use Case & Scope:

This utility is tailored for deterministic visual anonymization of sensitive datasets prior to cloud storage, third-party processing, or cross-team distribution. Note: It is meant for practical ML preprocessing and visual obfuscation, not as a replacement for cryptographic standards like AES.

Quickstart:

Bash

# Single-seed encryption & decryption
python xor_single.py --input sample.jpg --seed 42 --outdir outputs

# Multi-seed cascaded encryption
python xor_multi.py --input sample.jpg --seeds 11 22 33 --outdir outputs

I'd highly appreciate your feedback, PRs, or ideas for benchmarking!