Build Chatbots with LangChain and LLMs in Python

I have standardized the KahnQueue! Following up on a previous post where I introduced the idea of a KahnQueue, I have now standardized it across 4 languages who I think will benefit from it the most. From build systems to AI agents, Kahn's algorithm is everywhere, and we have all built our own implementation at one time or another. This is why I decided to make a standardized utility. KahnQueue is lightweight, priority queue-style data structure that standardizes dependency-ready scheduling across your entire stack. Same clean API. Same predictable behavior. Whether your workflows are simple or deeply complex. ✅ Zero dependencies ✅ Temporal-safe / fully deterministic mode ✅ Full hyperthreading / high-concurrency support ✅ Consistent API in Java, TypeScript, Python, and Go (alpha) If you're building AI agents, build tools, or orchestrators, KahnQueue eliminates the boilerplate and makes your dependency handling reliable and portable. https://lnkd.in/gcfqGxW2 #KahnQueue #Python #Java #Orchestration #OpenSource

TAP (Tool Abstraction Protocol) is LangChain's standardized way of describing tools so an AI agent knows exactly what to call and how to use it. Every tool in LangChain is defined with three things: 1. a name, 2. a plain English description that the LLM reads to decide when to use it 3. typed input schema generated automatically from your Python function using the @tool decorator. The LLM never executes your tool directly--it reads the schema, picks the right tool, generates a structured JSON with the correct arguments, and hands it back to your code for execution. TAP is what makes that handoff reliable by swapping tools, swapping models, or plug in any of LangChain's 600+ built-in integrations, and the agent always knows how to use them correctly because the schema never changes. In short, TAP is the contract that turns a Python function into something an LLM can reason about and use with confidence.

In 2026, "knowing Python" is the baseline. The real premium is on developers who can orchestrate. If you're looking to level up your stack this quarter, look past the hype and master these three libraries: 1)LangChain/LlamaIndex: For building real-world RAG pipelines and autonomous agents. 2)Pydantic v2: Essential for type-safe data validation in AI APIs. It’s powered by Rust now, making it blazing fast. 3)FastAPI: Still the king of modern backend, but the real power is how it integrates with asynchronous AI workflows.

Eliminate tool schema bloat! Give an AI agent 30+ MCP tools and thousands of tokens of JSON schemas eat the context window every turn. codemode-lite takes a different approach. Instead of flooding the agent with tool schemas, it exposes one tool: run_python. The agent writes Python, calls whatever tools it needs from inside a secure sandbox, and only the final result comes back. No schema bloat. No context growth. Two sandbox options: Podman containers for persistent state with enterprise isolation, or Pyodide WASM via Node.js for lightweight stateless execution. Add new MCP servers by dropping a JSON config. No code changes needed. Blog: https://lnkd.in/eTiBesX9 #AI #LLM #MCP #OpenSource #RedHat

Most people rush to write code. Very few pause to understand what code actually is. Python, at its core, is not just a programming language it’s a structured way of thinking. 🔹Take comments. They are ignored by the machine, yet essential for humans. That alone reveals something important not everything valuable in a system is meant for execution some things exist purely to create clarity and shared understanding. 🔹Variables may look simple, but they represent abstraction the ability to assign meaning to data. Naming rules are not arbitrary they enforce discipline. Clean names often reflect clean thinking, while messy names usually signal unclear logic. 🔹Then come data types integers, floats, strings, booleans. These are not just categories they are constraints. And constraints are what make systems predictable and reliable. A language that distinguishes between "12" and 12 is a language that demands precision in thought. 🔹Even string indexing carries a deeper idea any structure can be accessed, sliced, and interpreted differently depending on perspective forward or backward. It’s a reminder that how you look at something changes what you see. 🔹Type conversion introduces another subtle lesson. Sometimes transformation happens automatically (implicit), and sometimes it requires intent (explicit). Knowing when each occurs is the difference between control and assumption. 🔹And then there is truth in Python only a small set of values evaluate to false everything else is true. That’s not just syntax, it is a model of evaluation clear, minimal, and consistent. 🔹Finally, Python’s execution model bytecode and the Python Virtual Machine reminds us that what we write is never what the machine directly understands. There’s always a layer of translation. What feels simple at the surface is powered by deeper abstraction underneath. At this level, programming stops being about syntax. It becomes about systems, logic, constraints, and clarity of thought. #Python #PythonProgramming #Programming #Coding #SoftwareDevelopment #ComputerScience #Tech #TechThinking #LogicBuilding #ProblemSolving #Abstraction #DataTypes #Variables #LearnPython #CodingJourney #DevCommunity #SoftwareEngineering #BackendDevelopment #FullStackDevelopment #ComputerScienceStudents #DeveloperLife #CleanCode #CodeNewbie #TechEducation #ProgrammingFundamentals

While working through the qualifying rounds of IMC Prosperity this year, I kept running into the order book as a core piece of the simulation. I understood it conceptually but had never actually built one. So I did. I wrote a post walking through 4 iterations of a limit order book in Python, starting from a naive price-to-quantity mapping and working up to a concurrency-safe implementation. A few things I found interesting along the way: • The naive version looks fine until you try to cancel a specific order and realise you have no way to do it • Price-time priority (FIFO) completely disappears when you merge orders at the same level into one number • Adding a lock is easy. Adding a lock correctly, without deadlocking or killing throughput, is not • Figuring out the trade price is harder than it looks, especially once you introduce concurrency into the picture Full post and code on my site: https://lnkd.in/eBHgvQ9T #Python #Trading #Algorithms #TUDelft

𝗣𝘆𝘁𝗵𝗼𝗻 𝗔𝘀𝘆𝗻𝗰𝗜𝗢 𝗜𝗻𝘁𝗲𝗿𝗻𝗮𝗹𝘀 You use async def and await. You know the surface. Sometimes your code deadlocks. Or it runs slow. You need a mental model to fix this. Async Python is not parallel. It is concurrent. One coroutine runs at a time. If a coroutine does not yield, nothing else runs. A coroutine is a function. It pauses at specific points. It resumes later. The coroutine decides when to stop. The interpreter does not force it. The event loop drives the code. It calls send() on the coroutine. The await keyword pauses the task. It yields control back to the loop. Learn these three terms: - Coroutine: An object created by async def. It needs a driver. - Future: A placeholder for a value not yet ready. - Task: A wrapper. It schedules a coroutine on the loop. Do not block the loop. time.sleep stops the OS thread. The event loop stops too. Use asyncio.sleep instead. Use asyncio.to_thread for heavy CPU work. Cancellation is not a kill switch. It throws a CancelledError into the task. You must re-raise this error. If you hide it, the task stays alive. Async Python is a single-threaded scheduler. It runs callbacks in order. Everything works when coroutines yield often. Everything breaks when something holds the thread. Source: https://lnkd.in/gJPpwWR3

Most “slow APIs” in Python aren’t CPU-bound. They’re blocking the event loop without realizing it. Classic FastAPI mistake: @app.get("/users") async def get_users(): users = db.fetch_all() # blocking call return users Looks async. Isn’t. Result: * event loop stalls * requests queue up * latency spikes under load Fix → respect async boundaries @app.get("/users") async def get_users(): users = await db.fetch_all() return users Or offload properly: from asyncio import to_thread users = await to_thread(sync_db_call) Advanced production pattern: * separate sync + async layers clearly * use connection pools (asyncpg, aiomysql) * never mix blocking ORM calls inside async routes Hidden issue: One blocking call can freeze thousands of concurrent requests. Build-in-public lesson: Async isn’t about syntax. It’s about protecting the event loop at all costs. AI can convert code to async— but only experience catches where it’s still secretly blocking. #Python #BackendEngineering #FastAPI #Scalability #SystemDesign

Build a production AI agent in 10 lines of Python. Strands Agents SDK: ```python from strands import Agent from strands.models.bedrock import BedrockModel from strands_tools import calculator, web_search agent = Agent( model=BedrockModel("anthropic.claude-sonnet-4-20250514-v1:0"), tools=[calculator, web_search] ) response = agent("What's the GDP per capita of the top 5 economies?") ``` That's it. Tool calling, conversation management, streaming, multi-turn context is all handled. Why Strands over LangChain for AWS: - Built for Bedrock integration (not retrofitted) - Works with any Bedrock model - ToolSimulator for agent testing (just released) - Strands Evals for evaluation pipelines - Open-source, runs locally For production: pair with Bedrock AgentCore for managed deployment, guardrails, and observability. The stack: Strands (build) → ToolSimulator (test) → Strands Evals (evaluate) → AgentCore (deploy) Full lifecycle. Open-source foundation. Managed deployment when ready. Start: https://strandsagents.com #AWS #AIAgents #Python #Strands #Bedrock