From Zapier to Custom AI Apps with Python and PyTorch

I built an AI agent from scratch. No LangChain. No LangGraph. No CrewAI. Just Python, Gemini 2.5 Flash, and raw tool calling. Here's what I learned that no framework tutorial will teach you: 1. The agentic loop is embarrassingly simple Build messages → call LLM → if tool_call → execute → feed result back → repeat. That's it. Every framework is just a wrapper around this. Once you see it raw, you can never unsee it. 2. Frameworks hide your bugs from you When something breaks in LangChain, you're debugging the framework. When something breaks in raw Python, you're debugging your logic. Big difference. One makes you smarter. One makes you dependent. 3. Tool schema design is where agents actually fail The LLM doesn't call the wrong tool because it's dumb. It calls the wrong tool because your schema description was ambiguous. Write your tool descriptions like you're explaining them to a junior dev on their first day. Precise. No assumptions. 4. 50 lines of Python is enough to go to production My personal concierge agent — the one that lives on my portfolio, captures leads, and pings my phone instantly — is ~50 lines. No overhead. No magic. Just code I fully understand and can debug at 2am. 5. You should build one without a framework at least once Not because frameworks are bad. LangGraph is excellent. I'm using it next. But if you've never written the raw loop yourself, you're flying blind. You're trusting abstractions you don't understand. Build it raw first. Then use the framework. You'll use it 10x better. --- Full source code in the comments — ~50 lines, no magic, just the loop. Follow along if you're into agentic AI and building real things, not just demos. #AgenticAI #Python #BuildingInPublic #LLM #SoftwareEngineering

Start using “Code Mode” instead of LLM tool calling. The industry is shifting. Traditional Tool Calling—where an LLM outputs JSON and waits for a response—is becoming the "slow" way to build agents. It wastes tokens, adds latency, and increases the chance of hallucinations. Industry leaders agree that agents are better at writing code than managing multi-step JSON calls. Cloudflare highlighted this in their "Code Mode" article (https://lnkd.in/exY_cSpT), and Anthropic recently detailed the same shift in their "Code Execution with MCP" documentation (https://lnkd.in/eF3MNKKT). The consensus: We just need a secure, fast environment to run that code. Meet Monty (by the Pydantic team) Monty (https://lnkd.in/ek5hCy9E) is a minimal, secure Python interpreter written in Rust. It is designed specifically for AI agents: Microsecond Startup: no Docker overhead or heavy container management. Hardened Security: Built in Rust with a zero-trust environment. It has no access to your host system unless you explicitly grant it. I really recommend keeping an eye on this project and trying it out for yourself. I have been playing around with Monty lately and had the chance to contribute to the Pydantic team’s codebase to bridge a small gap that I encountered. PR here: https://lnkd.in/eJpDte7C Nerd out on the architecture via the Talk Python to Me episode: https://lnkd.in/enr6_K28 #Python #Rust #AI #Pydantic #OpenSource #LLMs

Most people getting into AI hear terms like LangChain, CrewAI, and Python and assume they’re all doing the same thing. They’re not, and understanding the difference changes how you actually build. Python is the foundation. It’s where everything runs. Data pipelines, model interaction, APIs, integrations. If you don’t understand Python, every framework on top starts to feel like a black box. LangChain sits above that as an application layer. It helps structure LLM-powered systems, handling prompts, memory, tool usage, and RAG pipelines. It’s not the only way to build, but it gives you a strong starting point for orchestrating behavior. CrewAI goes a step further into coordination. It focuses on multi-agent systems, where different agents take on roles, delegate tasks, and collaborate. Still early in many production environments, but directionally where things are going. Beyond these, real systems rely on more pieces. Tools like LlamaIndex for data retrieval, FastAPI for APIs, Hugging Face for models, vector databases like Pinecone or Weaviate, and layers for caching, observability, and optimization. What I’ve noticed is people rush into frameworks without understanding what’s underneath. But once you see the flow, Python first, then application logic, then coordination, everything starts to make a lot more sense. #AI #MachineLearning #LangChain #CrewAI #Python #RAG #LLM #AIDevelopment

Yesterday I shared how I set up a ruff linting hook in Claude Code that auto-cleans Python files every time Claude writes or edits one. But why is that even necessary? Here's the honest answer: AI doesn't always write perfect code, and neither do you or I. A few real scenarios where the hook quietly saves you: ✅ You edited a file manually: introduced a small lint issue, then asked Claude to add a feature elsewhere. Claude's edit triggers the hook. Ruff scans the whole file, not just Claude's changes. Your error gets caught too. ✅ Claude made a mistake: it's good, not infallible. The hook is a safety net that runs regardless of who introduced the issue. ✅ Accumulated drift: a file picks up small style inconsistencies over time. Every time Claude touches it, ruff tidies the whole thing. The codebase gets cleaner over time, not messier. The underlying principle: don't rely on either human or AI discipline for code quality. Automate it. This is what hooks in Claude Code are really for - not just reacting to what Claude does, but encoding your standards into the workflow itself so they're enforced consistently, every time. What quality checks are you automating (or wish you were)? #ClaudeCode #AI #Python #CodeQuality #DeveloperTools #Automation

Source: KDnuggets https://search.app/Y3EbX Introduction If you have built AI agents that work perfectly in your notebook but collapse the moment they hit production, you are in good company. API calls timeout, large language model (LLM) responses come back malformed — and rate limits kick in at the worst possible moment. The reality of deploying agents is messy, and most of the pain comes from handling failure gracefully. Here is the thing — you do not need a massive framework to solve this. These five Python decorators have saved me from countless headaches, and they will probably save you, too.

forty lines of python to make an “agent.” cute. great for demos, terrible as a promise of reliability. neat way to learn how tools, LLMs, and wiring fit together – but expect brittle glue, silent failures, and one weird input that breaks the loop at 3am. play with it, then refactor with retries, types, and tests. shrug.

I used to paste my entire codebase into an LLM every time I hit an error. Not because I wanted to. Because I was scared of missing context. Too little code → AI doesn't have enough to help. Too much code → AI gets lost in the noise. So I built Context Excavator. It reads your Python project and pulls out just the skeleton- which files exist, what's inside them, how they connect. One clean map instead of 400 messy lines. Three ways to use it: No error? It scans your architecture and flags risky functions Have an error? Paste it directly — agent traces exactly where it's coming from Don't want to type? It detects your error automatically from a log file Now when I get an error I paste the map, not the code. The LLM knows exactly where to look. Tech: Python, AST, Groq API (Llama 3.3 70B), Pathlib, Subprocess, Argparse, Markdown Shipped it as an open source CLI tool. If you've ever felt like you're fighting your AI assistant instead of working with it this might help. GitHub: https://lnkd.in/gGP3qxJs #Python #LLM #DevTools #OpenSource #BuildInPublic #AI #SoftwareDevelopment

𝗧𝗵𝗲 𝗙𝗮𝗰𝗲 𝗼𝗳 𝗖𝗼𝗱𝗲: 𝗕𝗎𝗶𝗅𝗱𝗶𝗻𝗴 𝗬𝗼𝘂𝗿 𝗢𝘄𝗻 "𝗚𝗼𝗼𝗴𝗹𝗲 𝗠𝗮𝗽𝘀 𝗳𝗼𝗿 𝗖𝗼𝗱𝗲𝗯𝗮𝗰𝗲𝘀" You join a new project or inherit a legacy system. You face a sprawling directory and thousands of lines of code. You ask: "How does this work?" Manually tracing logic is time-consuming and error-prone. What if you could build a tool to answer your questions about the code? We will construct a simplified "Codebase Q&A Engine" using Python. You will learn about code chunking, embedding, and semantic search. A "Google Maps for Codebases" is not a single AI model. It's a clever application of Retrieval-Augmented Generation (RAG). The process breaks down into: - Indexing: Make the codebase searchable. - Retrieval: Find the code most relevant to your question. - Generation: Use a Large Language Model to synthesize an answer. You can build the core of this tool yourself. Start by indexing and retrieving code. Then, integrate a language model to create the full Q&A loop. Your turn: Clone a small repository and run our engine on it. Ask questions and evaluate the results. Improve it by implementing AST-based chunking and integrating an open-source language model. Source: https://lnkd.in/gAhw_8B9

Built an AI agent that explores codebases and answers questions about them. No LangChain. No frameworks. Just raw OpenAI API. The agent has 3 tools: → list_files: explore directory structure → read_file: inspect file contents   → search_code: find where functions/classes are defined Ask it "How does the chunker work?" and it: 1. Lists files to understand structure 2. Searches for "chunk"  3. Reads the relevant file 4. Explains the implementation with line references Why raw API instead of LangChain? 50 lines of code taught me: - How tool calls are parsed - How the ReAct loop actually works - How to handle failures Frameworks hide this. Understanding primitives first = better debugging later. Code: https://lnkd.in/g8sJnA2Y Previous RAG used as codebase - https://lnkd.in/gABgPcFf What's the most useful agent you've built or seen? #AI #LLM #Agents #Python #OpenAI #BuildInPublic #SoftwareEngineering #AIEngineering #Langchain