Paramanantham Harrison’s Post

From CLI to Web: Building an LLM API Wrapper with Automatic Fallback 🚀 Built a Unified LLM API Wrapper with Python! I recently developed a comprehensive LLM API wrapper that provides a unified interface for multiple AI providers (Groq, OpenAI, Anthropic, Gemini) with automatic fallback support. ✨ Key Features: - Unified interface for multiple LLM providers - Automatic fallback if one provider fails - Both CLI and Streamlit web GUI - Streaming and non-streaming response modes - Token usage tracking for cost monitoring - Fully async/await support 🛠️ Tech Stack: - Python 3.x - Streamlit for web UI - Rich library for beautiful CLI - Pydantic for data validation - Async/await for non-blocking operations 💡 What I learned: - Designing abstract base classes for extensibility - Implementing fallback logic for reliability - Building both CLI and GUI interfaces - Working with async streaming responses #Python #AI #LLM #MachineLearning #Streamlit #SoftwareDevelopment #OpenSource

Most people don't realise how far you can push n8n when you pair it with Python. 🐍 I've just finished building something I'm pretty excited about. A Python sidecar service running alongside our n8n automation platform. It sounds more complicated than it is, but the impact is massive. Here's what was bugging me: n8n is brilliant for connecting apps, moving data and building workflows. But the moment you need serious data processing, JavaScript hits a wall pretty fast. And I kept running into that wall. So I built a FastAPI service that lives in the same Docker network as n8n. When a workflow needs heavy lifting, it fires off a request to Python, gets the result back, and carries on. From n8n's side it's just another HTTP node call. Simple. The difference in what's now possible is honestly kind of wild. Where JavaScript would struggle, Python just gets on with it. Pandas for processing thousands of rows in milliseconds. NumPy for calculations that would crash a spreadsheet. Access to pretty much every ML and AI library out there. Data cleaning, enrichment, financial modelling, NLP — all available inside a workflow with a single HTTP node. The whole thing runs self-hosted on Hetzner, locked down behind API key auth and internal Docker networking, so nothing is exposed that shouldn't be. The thing I keep coming back to is this. You don't need to rip out your low-code tools when they hit their limits. You just need to know where to extend them. n8n handles the orchestration. Python handles the intelligence. If you're building automation pipelines and finding yourself fighting against the tool rather than with it, I'd genuinely recommend looking at this pattern. Happy to share more if anyone's curious 👇 #n8n #Python #Automation #FastAPI #Docker #LowCode #WorkflowAutomation

It's 2026 and my AI assistant is still trying to solve every problem with a Python script. 🤦♂️ I ask for a Terraform provider — it wraps a CLI with subprocess. I ask for a modern SDK integration — it spits out a requests + json.loads + try/except mess. And when it can't solve anything? It just paraphrases the manual. I can read the docs myself, what do I need you for? The real issue isn't even code quality — it's **focus drift.** AI pulls you away from your actual goal and you don't even notice. Next thing you know, you've burned 45 minutes and 30 prompts, and instead of an architectural solution you're staring at 4 interdependent Python files. Quota gone, problem still there. These "smart" workflows sometimes take more effort than doing it manually. Those of you who actually use AI productively — how do you stop it from derailing you? 🐍🚫 #SoftwareArchitecture #AIReality #PlatformEngineering #CleanCode

Docker is too heavy for Agentic Control Loops. We need a μs-scale Python runtime. 🐍🦀 As AI Architects, we are all building "Code Sandboxes" right now. Whether it's for an internal "Code Interpreter" or an Agentic tool-use loop, we usually default to spinning up a Docker container or a Firecracker microVM. The problem? Latency. Waiting 500ms+ for a container to cold-start kills the "thought-loop" cadence of an Agent. Pydantic just released Monty (pydantic/monty), and it’s a radical alternative: A minimal Python interpreter written in Rust. The Architectural Primitive: Instead of isolating code at the OS level (Containers), it isolates it at the Interpreter level. Microsecond Cold Starts: It creates a sandbox in single-digit microseconds. This allows for tight "Think-Code-Result" loops without the infrastructure overhead. Snapshot-Based State: The entire interpreter state can be serialized to bytes. You can pause an agent's execution, store the "brain" in a database, and resume it on a different machine later. Deny-by-Default: It doesn't have os or network access. You explicitly inject "External Functions" (like fetch_data), meaning the Agent can calculate logic in Python but can only touch the world through your defined API surface. It’s currently experimental (supports a subset of Python), but if you are building high-throughput Agent Swarms, this is the runtime you've been waiting for. 👇 Link to the repo in the comments. ==== Share this with your network if you found this insightful ♻️ Follow me (Bunty Shah) for more AI Architect's insights and tutorials on GenAI and Machine Learning! ==== #AIArchitecture #Pydantic #Rust #Python #AgenticAI #LLM #Sandboxing #SystemDesign #OpenSource

I asked Claude Code to stop wasting my tokens. It told me to stop using it. I was converting Confluence pages to markdown by passing them through Claude Code. Page after page. Every conversion cost tokens - for something that's just a format change. So I asked Claude Code: you're spending too many tokens on this. What's the token-optimized way? Its answer: use Pandoc. This doesn't need me. I built a Python script. It calls the Confluence REST API, downloads the page, and runs Pandoc for the conversion. Zero tokens. But then 3 things broke: 1. Images were not getting downloaded in the .md file 2. Table formatting was not proper 3. Status labels and @mentions were not converting to markdown Multiple iterations later - the script now handles all of it. Pages convert to markdown without missing anything. Proper formatting. No token cost. The thing that stuck with me: I wasn't wasting tokens on hard problems. I was wasting them on mechanical tasks that a Python script handles better. If you're using Claude Code, Antigravity, Cursor, or any AI tool - try this before your next conversion. Ask yourself: does this need intelligence, or is it just a format change? If it's just format - write a script. Save the tokens for the work that actually needs thinking. Feel free to connect if you want to know more. Happy to help. #ClaudeCode #Python #Confluence #BuildInPublic #AITools

𝐇𝐨𝐰 𝐀𝐈 𝐀𝐠𝐞𝐧𝐭𝐬 𝐀𝐜𝐭𝐮𝐚𝐥𝐥𝐲 𝐖𝐨𝐫𝐤? 𝐉𝐮𝐬𝐭 𝐋𝐨𝐨𝐩𝐬, 𝐒𝐭𝐚𝐭𝐞, 𝐚𝐧𝐝 𝐃𝐞𝐜𝐢𝐬𝐢𝐨𝐧𝐬 Agent frameworks like LangChain make things feel easy: Connect tools → add memory → run an agent. Recently I explored an open-source repo that builds agents completely from scratch. You start seeing what’s actually happening underneath the abstractions. Just Python, local LLMs, and first-principle design. Instead of thinking in “chains” or prebuilt components, you think in systems: Observe → Decide → Act → Repeat. You realize an agent is really just: - Direct LLM calls controlling behavior with system prompts - Structured JSON outputs that make responses executable - Routing logic deciding what happens next - Simple Python functions giving real-world capability - Memory that carries context across sessions - Planning that breaks goals into atomic actions - Dependency graphs (“Atom of Thought”) for complex reasoning Frameworks like LangChain are powerful accelerators. But building the loop yourself teaches you why agents succeed or fail. It changes how you design autonomy. It’s structure and state. Exploring agents beyond plug-and-play abstractions is real understanding. This repo is a great place to start: https://lnkd.in/d9uT5WDF Food for thought - do you start with frameworks like LangChain, or build from primitives first? #AI #LLM #LangChain #Agents  #MachineLearning #Python #LocalLLM

Day 19/30: Giving the AI Agent a Face (Streamlit UI) 📈 We often run AI in the terminal, but real users need a dashboard. Today, I took my Python logic and wrapped it in a Full-Stack Web App using Streamlit. What I Built: A Real-Time Financial Dashboard that simulates an AI Agent fetching stock data. Key Technical Features: Session State Management: The app "remembers" previous searches and builds a history log (unlike a standard script that forgets everything after execution). Dynamic Visualization: Renders live price charts using Pandas and Streamlit native charts. Metric Tracking: Auto-calculates portfolio value based on live inputs. It’s amazing how 50 lines of Python can turn a backend script into a user-ready product. Tech Stack: Python, Streamlit, Pandas, Session State. #GenerativeAI #Streamlit #Python #FullStack #BuildInPublic #Day19

🚀🚀 Excited to share something I’ve been building! I recently built a Python library called Chuscraper — focused on stealth web scraping & browser automation. It’s designed to work better on modern websites where normal scrapers fail because of anti-bot protections. ✅ Async-based scraping ✅ Proxy support (with auth) ✅ Stealth scripts to reduce detection ✅ Clean & simple API for automation I’m actively improving it (proxy tunneling, better stealth fingerprinting, stability improvements), and AI-based automation features are also coming soon. 🔗 GitHub: https://lnkd.in/dJvEeCrV Would love feedback from the community 🙌 If you’re into scraping/automation, do check it out! #Python #WebScraping #Automation #AI #OpenSource #aiscraping

🚀 Scaling Python AI & Long-Running Tasks with Rust: Introducing RestWs >> Sync Simplicity, Async Power: REST-Call in, WebSocket-Stream out << Are you struggling with REST API timeouts during heavy AI inference or complex data processing? Traditional task queues add significant infrastructure overhead, while standard async Python can still hit bottlenecks. I’m excited to share RestWs, a high-performance web server engine built in Rust (and Python) designed specifically to decouple heavy workloads from the HTTP lifecycle. ❓ The Problem: Modern APIs face scalability challenges when handling long-running tasks. These workloads block the request-response cycle, leading to client timeouts and resource exhaustion. 💡 The Solution: RestWs implements the ASGI standard to bridge the gap between low-level systems performance and high-level Python logic. It allows you to write synchronous Python while the Rust engine manages the heavy lifting through a unique "Process Split." 🔑 Key Features: The Split: Trigger a background task that automatically pipes stdout/logs directly to a persistent WebSocket while the initial HTTP request resolves. Zero-Downtime Hot-Reload: Deploy new Python code without dropping active WebSocket connections. Compatibility: Works seamlessly with FastAPI and other ASGI compatible frameworks. ⚡ RestWs is currently in the experimental phase and is perfect for developers looking to simplify their stack while maintaining massive throughput for streaming data and AI applications. Links to the source code, binary and a working demo application (Python FastAPI backend and JavaScript frontend) can be found in the comments. #Python #Rust #WebSockets #BackendEngineering #RestWs #AI #Scalability #OpenSource

Whoa … Amazing how much faster #Rust is on so many tasks than #Python. There’s a lot of philosophical discussion around Rust vs. Python. So I ran a simple benchmark instead. Test setup: - Generate 5 million records - Hash each record (SHA-256) - Group by hash prefix - Measure execution time + peak memory No I/O. No tricks. Just CPU + memory pressure. Results on my machine (M2 MacBook Air, 24 GB RAM): 🐍 Python: ~8–12 seconds, ~800–1200 MB peak memory 🦀 Rust (release build): ~0.7–1.5 seconds, ~250–350 MB peak memory That’s not “a bit faster.” That’s an order of magnitude difference in speed — and significantly tighter memory behavior!!! Why? Python: - Interpreter overhead per loop - Boxed objects - Heavy dictionaries - GC + ref counting Rust: - Zero-cost abstractions - Tight memory layout - No GC - Native compiled code But raw performance is only one axis. If I’m building: - API orchestration - AI workflows - Rapid prototypes - Business logic Python wins on time-to-value. If I’m building: - High-volume data pipelines - Graph ingestion engines - Hash-heavy processing - Systems-level infrastructure Rust is in a different league. The real answer isn’t “Rust or Python?” It’s: Where does performance actually matter in your architecture? Curious how others decide where to draw that boundary. What do you think?