标签：#Python

I Spent Two Weeks Pitting Qwen 3 Max Against DeepSeek V4 I want to tell you about a rabbit hole I fell into recently. It started the way most of my projects do — someone on a Discord server I frequent asked a simple question: "Should I use Qwen 3 Max or DeepSeek V4 for my internal_compare workflow?" I had opinions, sure, but I wanted real numbers. So I cleared my calendar, fired up a couple of GPU instances, and started benchmarking. What I found surprised me, and it also reinforced something I've been saying for years: the open source ecosystem is winning, and the walled gardens of the proprietary AI world are starting to look pretty silly. Let me walk you through what I learned, the actual numbers I got, and why I keep coming back to open weight models with permissive licenses (looking at you, Apache 2.0 and MIT). Why I Care About This in the First Place I've been burned too many times by closed source vendors changing their pricing overnight, deprecating models without warning, or locking features behind enterprise tiers. You know the drill. The moment your application depends on a proprietary API, you're renting infrastructure you can't inspect, can't fork, and can't run on your own hardware. That's not a partnership — that's a leash. When a model ships under Apache or MIT, I can download the weights, audit the architecture, fine-tune it on my own data, and deploy it wherever I want. Nobody can rug-pull me. Nobody can raise prices because some quarterly earnings call didn't go their way. That's freedom, and freedom matters more than people think when you're building anything serious. So when I started this comparison, I was already rooting for the open weight contenders. But I wanted to be honest about the results, even if they complicated my bias. The Lineup I Tested Global API currently exposes 184 models through a single unified endpoint, which is honestly wild. I picked five that I thought represented the interesting tradeoffs between cost, capability, and o

Cómo un backend de FastAPI + asyncpg comparte un solo Postgres chiquito con sus propios trabajadores en segundo plano y un segundo servicio, por qué el techo de conexiones, no el CPU, es lo que de verdad le pone tope a nuestro autoescalado, la caída en el cambio de hora que nos enseñó la cuenta, y una mirada honesta a RDS Proxy como la válvula de escape (incluyendo la trampa de asyncpg que lo puede dejar sin hacer nada). TL;DR Ajuste Valor Por qué Driver postgresql+asyncpg asíncrono hasta el fondo pool_size / max_overflow 8 / 12 (20 por proceso) subido desde 3/5 después de una caída pool_pre_ping True mata los sockets muertos tras un reinicio de RDS / inactividad pool_recycle 1800 s techo duro que el pre-ping no puede cubrir Tope de conexiones de RDS ~87 (t3.micro, menos las reservadas) la verdadera restricción de todo Pruebas NullPool sin pooling entre event loops en pytest La lección que replanteó todo el problema: en un RDS chico, tu cuenta máxima de tareas la fija max_connections , no el CPU ni la memoria. Un autoescalado que ignora el presupuesto de conexiones va a escalar directito hacia QueuePool limit reached , o peor, FATAL: too many connections del mismo Postgres. El pool, y la cuenta escondida adentro de él engine = create_async_engine ( settings . DATABASE_URL , connect_args = { " ssl " : " prefer " }, # negocia TLS en RDS, texto plano en local pool_pre_ping = True , pool_size = 8 , max_overflow = 12 , # 8 + 12 = 20 conexiones por proceso pool_recycle = 1800 , ) Veinte conexiones por proceso se ven modestas hasta que las multiplicas por cada capa entre ellas y la base de datos: pool_size + max_overflow = 20 por proceso de Python × 2 trabajadores de uvicorn = 40 por tarea de Fargate × 2 durante un despliegue rolling = 80 (tarea vieja drenando + tarea nueva arrancando) + servicio de inteligencia (3 + 7) = 10 sobre la misma base de datos + alembic / ad-hoc / psql ≈ unas pocas ---------------------------------------- ≈ 87 ← el techo de la t3.micro, con ~0 de

GitHub热门项目 | AI coding assistant skill (Claude Code, Codex, OpenCode, Cursor, Gemini CLI, and more). Turn any folder of code, SQL schemas, R scripts, shell scripts, docs, papers, images, or videos into a queryable knowledge graph. App code + database schema + infrastructure in one graph. | Stars: 67,157 | 5,478 stars this week | 语言: Python

We've all been there: staring at a clunky, 10-year-old hospital web portal, clicking through endless nested menus just to book a simple check-up or download a PDF lab result. It's tedious, error-prone, and frankly, a waste of human potential. But what if you could just tell an AI, "Book me a dermatologist for next Tuesday and save my blood test results to my health folder," and it just... did it? In this tutorial, we are diving deep into the world of autonomous agents , GPT-4o , and LLM-driven web navigation . By leveraging the revolutionary Browser-use library and Playwright , we’ll build a vision-capable agent that can navigate complex UIs, handle logins, and automate the most frustrating parts of healthcare administration. 🚀 Why Traditional Scraping Fails (and Why Agents Win) Traditional automation tools like Selenium or Puppeteer rely on brittle DOM selectors ( #button-id-342 ). When a hospital updates its website, your script breaks. Using Browser-use with GPT-4o changes the game. Instead of looking for code, the agent sees the page like a human, understanding that a magnifying glass icon means "Search" regardless of the underlying HTML. The Architecture 🏗️ The system logic involves a feedback loop where the LLM perceives the browser state (screenshot + DOM tree), decides on an action, and executes it via Playwright. graph TD A[User Goal: Book Appointment/Download Report] --> B[LangChain Agent / Browser-use] B --> C{Decision Engine: GPT-4o} C --> D[Action: Click/Type/Scroll] D --> E[Playwright Browser Instance] E --> F[Hospital Portal UI] F --> G[Visual & HTML Feedback] G --> C F --> H[Download Lab Report PDF] H --> I[Structured Storage / RAG Pipeline] I --> J[Task Completed ✅] Prerequisites 🛠️ Before we start, ensure you have the following in your tech stack: Python 3.10+ Playwright (The backbone of browser control) Browser-use (The bridge between LLMs and browsers) OpenAI API Key (We'll use GPT-4o for its superior vision capabilities) pip install browser-use

🚀 CKA Exam Overview: What Every Kubernetes Engineer Should Know Before Starting If you're working in DevOps, Cloud Engineering, Platform Engineering, or SRE, chances are you've heard about the Certified Kubernetes Administrator (CKA) certification. But here's what surprises most people: ⚠️ There are no multiple-choice questions. You get a real Kubernetes environment and must perform actual administrative tasks within a limited time. That makes the CKA one of the most practical certifications in the cloud-native ecosystem. 📋 CKA Exam Pattern Category Details Exam Type Performance-Based Duration 2 Hours Environment Live Kubernetes Cluster Passing Score ~66% Proctoring Online Remote Proctored Difficulty Intermediate to Advanced 🎯 Core Domains 1️⃣ Cluster Architecture, Installation & Configuration Cluster setup Control Plane components Certificate management Cluster upgrades 2️⃣ Workloads & Scheduling Deployments StatefulSets DaemonSets Jobs & CronJobs 3️⃣ Services & Networking Services Ingress DNS Network Policies 4️⃣ Storage Persistent Volumes Persistent Volume Claims Storage Classes 5️⃣ Troubleshooting Node failures Pod failures Control Plane issues Network troubleshooting Why CKA Matters in 2026 Modern organizations running workloads on AWS, Azure, and GCP increasingly rely on Kubernetes. A certified administrator demonstrates the ability to: ✅ Manage production clusters ✅ Troubleshoot incidents efficiently ✅ Maintain reliability and scalability ✅ Support cloud-native application deployments These skills directly align with DevOps and SRE responsibilities. My 90-Day CKA Challenge I'm beginning a structured 90-day CKA preparation journey. Over the next few months, I'll share: Study notes Lab exercises Troubleshooting scenarios Exam strategies Kubernetes tips & tricks Real-world DevOps and SRE learnings Discussion Time 👇 If you've already taken the CKA: 👉 What was the hardest section for you? If you're preparing: 👉 What's your biggest challenge right now? Let's learn

Started looking for a tourism dataset on Kaggle for a new project. Found one with real UNWTO data, but it only went up to 2022 — not enough for what I wanted (post-COVID trends). Then found a better-looking one: "Global Tourism & Travel Trends (2019-2024)," 24 upvotes, great coverage range. Almost picked it on the spot. Then I actually read the full description. Turns out it's synthetic — 10,000 generated records, not real recorded stats. Had to rename the whole project: from "Travel Recovery Analysis" to "Travel Behavior & Satisfaction Trends (2019-2024)" — same dataset, just honest framing. Still great for practice: 33 features, zero nulls, covers spend, satisfaction, eco-choices, transport modes. Anyone else ever almost build a project around the wrong assumption about their data? 👀

Hi everyone, I've been hacking on a local personal memory system called Hillock . Honestly, it's very much a work in progress and it isn't some flawless breakthrough, but I wanted to see if we could build a lightweight, completely offline memory layer for local LLMs without the overhead of running a heavy neural vector database or wasting precious VRAM. The project is named after the biological Axon Hillock —the exact gatekeeper region of a human neuron that sums up incoming electrical charges and decides whether to fire (open the gate) or remain silent (block). How the architecture works: The Ground Truth (SQLite) : Stores hard facts as simple database triples (Subject-Predicate-Object) so the system has a solid symbolic foundation. The Synapses (Hebbian Plasticity) : Tracks which concepts co-occur during a conversation to dynamically build gradient-free associative weights. The Context (Hyperdimensional Computing) : Maintains a 10,000-dimensional leaky context vector that rolls, binds, and accumulates history. This helps the system resolve pronouns (like "he/she") and decide when to block a query to prevent hallucinations. The Honest Benchmarks (Yes, it breaks!) I wrote a tough, 30-sentence scientific benchmark with complex sentence structures and hard negatives (like asking what Einstein discovered when the text only mentions Curie discovering radioactivity and Einstein working with her). Running Qwen 1.5B locally on my computer, here is how it actually did: Extraction Precision : 10.6% Extraction Recall : 22.7% Retrieval Accuracy : 30.0% Gate Accuracy : 30.0% Why are these scores low? Because a tiny 1.5B model completely trips over complex English grammar during ingestion (it gets confused and creates weird predicates). However, the actual HDC vector-matching itself is incredibly stable. I enforce a Constant-Component-Count of exactly 3 components per fact, which balances the vector norms and keeps retrieval highly reliable once the facts are actually in the dat

The blast radius of an API key is not "did it leak." It's "if the agent holding it does the wrong thing, how much of your stack goes with it." A secret scanner answers the first question. Nothing in your toolchain answers the second one before an incident. So I wrote 40 lines that do, offline, from the permission metadata you already have. In short: the blast radius of an API key is set by its permissions, not by whether it leaked: scope width × environment isolation × lifetime × revocability. blast_radius.py reads that metadata (never the secret value, never the network) and scores each key 0–100. In my run a broad prod token hit 91/100 CRITICAL; a scoped key, 14/100 CONTAINED. Stdlib, keyless, deterministic. AI disclosure: I wrote blast_radius.py with AI assistance and ran it myself before publishing. Every score in the output blocks below is pasted from a real run on a synthetic fixture I'll show you — no real keys exist in it; every value is a placeholder like sk-FAKE-… . The incidents I cite ($82K, 9 seconds, 2,863 keys, 93%) are other people's , and I link each source next to it. I label which is which. A token that could delete the database, used to manage domains On April 24, 2026, a Cursor agent running Claude Opus 4.6 dropped a production database, and the volume backups with it, in about 9 seconds, on one API call . The team behind PocketOS wrote it up. The agent hit a credential mismatch, went looking, and found a long-lived Railway CLI token sitting in an unrelated file. That token had been minted to manage domains. But it carried blanket authority over the whole Railway account, volumeDelete included. No scope tied to an environment. No read-only mode. Recovery took the weekend ( The New Stack, 27 Apr 2026 ; The Register, 27 Apr 2026 ). Read that again, because the lesson isn't "the agent went rogue." The lesson is the token . A domain-management task does not need volumeDelete . The key was over-scoped before the agent ever touched it. The agent didn'

Giving an LLM a database connection is one of those ideas that sounds great in a demo and terrifying in production. The agent writes a slightly-wrong query, and now you're explaining to your team why orders is empty. So when I wanted an AI agent (Claude Desktop, in my case) to answer questions about a SQLite database, I didn't want to hand it a read-write connection and hope for the best. I built a small MCP server that gives the agent read-only SQL access — and I made "read-only" mean it, with two independent layers of protection. Here's how it works, and the design decisions that matter. Full source: github.com/skycandykey1/mcp-sqlite-server (MIT). A 30-second primer on MCP The Model Context Protocol (MCP) is an open standard for connecting AI apps to tools and data. An MCP client (Claude Desktop, Claude Code, Cursor, ...) connects to MCP servers that expose three kinds of capability: Tools — functions the model can call ( query , list_tables , ...) Resources — read-only data the model can pull in (a schema, a file) Prompts — reusable prompt templates The Python SDK ships a high-level helper, FastMCP , that turns this into a few decorators. The interesting part isn't the protocol — it's the safety design behind the tools. Design: keep the dangerous part away from the protocol The first decision: the read-only safety logic has zero MCP dependency. It lives in a plain module ( db.py ) that knows nothing about MCP, so I can unit-test it with nothing but the standard library. The server ( server.py ) is a thin wrapper. That separation matters: the part that must never be wrong (write protection) is testable in isolation, without spinning up an MCP client. Two layers of write protection A single guard is a single point of failure. So write protection happens twice, independently. Layer 1 — open the database read-only at the engine level: import sqlite3 def connect ( path : str ) -> sqlite3 . Connection : """ Open a SQLite database in READ-ONLY mode. Any write raises Op

You have 50 documents and you're running them through an LLM in a loop. The first one finishes at the 2-second mark. The fiftieth finishes at the 100-second mark — not because it's harder, but because it waited in line behind the other 49. Pool runs all 50 at the same time. The Problem With Loops Every developer who works with LLMs writes this code eventually: import os from yait_aichain.models import Model from yait_aichain.skills import Skill skill = Skill ( model = Model ( " claude-sonnet-4-6 " , api_key = os . getenv ( " ANTHROPIC_API_KEY " )), input = { " messages " : [{ " role " : " user " , " parts " : [ " Summarise in two sentences: \n\n {text} " ]}]}, ) documents = [{ " text " : f " Document { i } content... " } for i in range ( 50 )] results = [] for doc in documents : result = skill . run ( doc ) results . append ( result ) It works. It's readable. And it's painfully slow. Each LLM call takes roughly 2 seconds. Multiply that by 50 documents and you're staring at your terminal for almost two minutes. The calls are completely independent — document 37 doesn't need the result of document 12. Yet document 37 sits idle, waiting its turn. That's a scheduling problem, not a computation problem. I ran into this directly while building a task that pulled N files or links and produced a consolidated report. The sequential version was logically fine but just hemorrhaged time. I needed to fire everything at once without rewriting the Skill logic — no new prompt templates, no restructured code, just a different execution model. That's what Pool is. Pool: Parallel Map for LLM Calls Pool takes one Skill (or Chain) and a list of inputs , then launches all of them concurrently. Think of it as Array.map() where every element runs in parallel against an LLM. import os from yait_aichain.models import Model from yait_aichain.skills import Skill from yait_aichain.pool import Pool , DONE , FAILED skill = Skill ( model = Model ( " claude-sonnet-4-6 " , api_key = os . getenv ( "

GitHub热门项目 | 🏡 Open source home automation that puts local control and privacy first. | Stars: 87,712 | 32 stars today | 语言: Python

GitHub热门项目 | Run, manage, and scale AI workloads on any AI infrastructure. Use one system to access & manage all AI compute (Kubernetes, Slurm, 20+ clouds, on-prem). | Stars: 10,141 | 46 stars today | 语言: Python

GitHub热门项目 | A lightweight coding agent for open models like Deepseek, Kimi, and Qwen | Stars: 63,947 | 45 stars today | 语言: Python

GitHub热门项目 | The pytest framework makes it easy to write small tests, yet scales to support complex functional testing | Stars: 13,942 | 8 stars today | 语言: Python

Weekly Challenge 377 Each week Mohammad S. Anwar sends out The Weekly Challenge , a chance for all of us to come up with solutions to two weekly tasks. My solutions are written in Python first, and then converted to Perl. Unless otherwise stated, Copilot (and other AI tools) have NOT been used to generate the solution. It's a great way for us all to practice some coding. Challenge , My solutions Task 1: Reverse Existence Task You are given a string. Write a script to find whether any substring of length 2 is also present in the reverse of the given string. My solution This is relatively straight forward. I create a variable reversed_string which is the string reversed. I then have a loop called start_pos that goes from 0 to 2 less than the length of the string. At each position, I check if the two letters at that position are in the original string. def reverse_existence ( input_string : str ) -> bool : reversed_string = input_string [:: - 1 ] for start_pos in range ( len ( input_string ) - 1 ): if reversed_string [ start_pos : start_pos + 2 ] in input_string : return True return False The Perl solution follows the same logic. sub main ($input_string) { my $reversed_string = reverse ( $input_string ); foreach my $start_pos ( 0 .. length ( $input_string ) - 2 ) { if ( index ( $input_string , substr ( $reversed_string , $start_pos , 2 ) ) != - 1 ) { say " true "; return ; } } say " false "; } Examples $ ./ch-1.py abcba true $ ./ch-1.py racecar true $ ./ch-1.py abcd false $ ./ch-1.py banana true $ ./ch-1.py hello true Task 2: Prefix Suffix Task You are given an array of strings. Write a script to find if the two strings ( str1 , str2 ) in the given array such that str1 is prefix and suffix of str2. Return the total count of such pairs. My solution In Python, this is a one line solution. I use the combinations function from the itertools module to produce all combinations of pairs of str1 and str2 . For each pair, I use the startwith and endswith function on the strings

6 months ago I was a final year CS student with no real projects and no clear path into tech. So I built one. Not just a project. A full platform. Here's everything inside Rohith Builds — completely free, forever. What's Inside 1. 100 Structured Lessons (Python → AI) Not random tutorials. A structured path: Day 1-20: Python basics Day 21-40: Backend & APIs Day 41-60: SQL & Databases Day 61-80: AI & LLMs Day 81-100: AI Agents & Launch Every lesson uses Indian examples. Zomato orders. Cricket scores. IRCTC bookings. Aadhaar validation. Because most tutorials use pizza and baseball. We use what we actually know. 2. Rohi — AI Tutor Stuck on a concept? Ask Rohi. he's powered by Groq LLM, understands Indian context, and is available 24/7. No waiting for a mentor to reply. No expensive bootcamp. Just ask and learn. 3. Jobs Board — Updated Daily This took the longest to build. An autonomous scraper that: → Queries LinkedIn Guest API → Searches Naukri via AOL gateway → Finds Indeed listings → Sends each to Groq AI for analysis → Filters only junior/fresher roles → Checks freshness (last 4 days only) → Removes duplicates automatically → Inserts into PostgreSQL Result: 53+ curated jobs. Updated daily. Filter by: Python, Backend, AI, Frontend Filter by: 2025, 2026, 2027 graduates No more scrolling through senior roles pretending to be junior. 4. 220+ Prompt Vault Every prompt I've used to: Debug faster Write better code Prepare for interviews Build projects Copy. Use. Customize. 5. Improve Any Prompt (Free Tool) Paste any AI prompt. Get an optimized version instantly. No signup needed. The Tech Stack Built with: Python + Flask PostgreSQL (Neon) Groq API (Llama-3.3-70b) Render deployment SQLAlchemy + psycopg2 No React. No Next.js. No hype stack. Just Python and PostgreSQL doing real work. Why I Made It Free Because every resource that helped me was either: Paywalled after lesson 3 In English accent I had to rewind Using examples I couldn't relate to Assuming I had a MacBook and

I Built a Consistent Hashing Ring in Pure Python and Finally Understood How Cassandra Distributes Data I've been using Cassandra and Redis Cluster for years. I knew consistent hashing was "how they work." But I never truly got it until I built one myself from scratch, in pure Python, with zero dependencies. This post is about what I learned doing that. The Problem Consistent Hashing Solves Imagine you have 3 servers and 1 million keys. The naive approach: server = hash(key) % 3 . It works great until you add or remove a server. Change 3 to 4, and almost every key remaps to a different server. In a caching layer, that means near 100% cache miss. In a database, it means massive data movement. That's the problem consistent hashing solves. When you add or remove a node, only a fraction of keys move. Specifically, 1/n of the keys, where n is the number of nodes. Building the Ring The core idea: place both nodes and keys on a circular number line from 0 to 2^32 (or any large integer). To find which node owns a key, walk clockwise until you hit a node. Here's the minimal version: import hashlib import bisect class ConsistentHashRing : def __init__ ( self , replicas = 150 ): self . replicas = replicas self . ring = {} # hash -> node name self . sorted_keys = [] # sorted hash positions def _hash ( self , key : str ) -> int : return int ( hashlib . md5 ( key . encode ()). hexdigest (), 16 ) def add_node ( self , node : str ): for i in range ( self . replicas ): virtual_key = f " { node } :vnode: { i } " h = self . _hash ( virtual_key ) self . ring [ h ] = node bisect . insort ( self . sorted_keys , h ) def remove_node ( self , node : str ): for i in range ( self . replicas ): virtual_key = f " { node } :vnode: { i } " h = self . _hash ( virtual_key ) del self . ring [ h ] idx = bisect . bisect_left ( self . sorted_keys , h ) self . sorted_keys . pop ( idx ) def get_node ( self , key : str ) -> str : if not self . ring : raise ValueError ( " Ring is empty " ) h = self . _hash

When I first started exploring Machine Learning, I made the same mistake most beginners do — I jumped straight into neural networks and model training without really understanding the Python underneath. I'd copy code from tutorials, get it running, and have zero idea why it worked. Then I started going through a structured Python-for-ML curriculum — and everything changed. This post is a distillation of that journey. If you're a CS student or early-career developer who wants to work seriously in ML/AI, here's the complete Python foundation you need — with the why , not just the what . Why Python Specifically? (It's Not Just Hype) Python isn't the fastest language. C++ blows it out of the water on speed — and I've personally used C++ for packet-capture modules in one of my ML projects. But Python dominates ML for one reason: the ecosystem . NumPy, Pandas, PyTorch, TensorFlow, Scikit-learn, Hugging Face — all Python-first. You don't choose Python for ML. The field chose it for you. Stage 1: Python Basics — The Foundation You Can't Skip Before you touch any ML library, you need these locked in. Variables and Data Types Python is dynamically typed, which feels nice at first but will bite you during data preprocessing if you're not careful. # These are all valid — Python infers the type name = " Parth " score = 8.97 is_enrolled = True year = 2025 For ML, the types that matter most are int , float , bool , and str — and knowing when Python silently converts between them (type coercion) can save you hours of debugging. Loops and Conditions — Your Data Iteration Backbone grades = [ 8.5 , 7.9 , 9.1 , 6.8 , 8.97 ] for g in grades : if g >= 8.5 : print ( f " Distinction: { g } " ) elif g >= 7.0 : print ( f " First Class: { g } " ) else : print ( f " Pass: { g } " ) Simple? Yes. But this exact pattern — iterate over a collection, branch on conditions — is the mental model for 80% of data cleaning code you'll write later. Functions and Lambda Expressions Functions are how you st

From Demo Code to a Reusable Package Article 19 used a 900-line harness_full_demo.py to demonstrate eight defense layers. That file is good for explaining concepts, but not for reuse — all layers are coupled together, nothing can be tested in isolation, and nothing can be imported by another project. A production-grade Agent project needs something you can actually import : harness/ ├── __init__.py Public API exports ├── registry.py Layer 2: ActionRegistry + PermissionLevel ├── budget.py Layer 3: PermissionBudget (with refund()) ├── sandbox.py Layer 4: sanitise_input + sandboxed_eval ├── audit.py Layer 6: ImmutableAuditLog (hash-chained) ├── rollback.py Layer 7: RollbackCoordinator └── harness.py Unified entry point: AgentHarness This article starts with package design, covers three key API decisions, and finishes with two integration styles: standalone Python and LangGraph graph embedding. Module Design registry.py — Layer 2 class PermissionLevel ( Enum ): READ = 1 WRITE = 2 ADMIN = 3 IRREVERSIBLE = 4 @dataclass class RegisteredAction : name : str level : PermissionLevel budget_cost : int description : " str " handler : Any # Callable or BaseTool class ActionRegistry : def register ( self , action : RegisteredAction ) -> None : ... def get ( self , name : str ) -> RegisteredAction : ... # not found → PermissionError def is_allowed ( self , name : str ) -> bool : ... def names ( self ) -> list [ str ]: ... get() rather than __getitem__ : raises a consistent PermissionError , without leaking the internal KeyError detail. budget.py — Layer 3 class PermissionBudget : def spend ( self , action_name : str , cost : int ) -> None : if self . remaining < cost : raise BudgetExhaustedError (...) self . remaining -= cost def refund ( self , action_name : str , cost : int ) -> None : self . remaining = min ( self . total , self . remaining + cost ) The new refund() method fixes a design flaw from Article 19: budget was deducted before approval, and never returned on rejection.

Check this out: i Cut Our Image Captioning Costs 60% — Here's the Backend Story Look, I'll be honest. Six months ago I didn't think twice about image captioning. We were a small team, traffic was low, and we just threw everything at GPT-4o because it was the path of least resistance. Then our infra bill came in, my manager did that thing where he just stares at the dashboard, and suddenly I was a "cost optimization" guy. fwiw, that was not in my job description. This is the story of how I went from "we just use GPT-4o for everything" to a multi-model setup that cut our spend by more than half, with quality that — imho — is actually better than what we had before. No, this is not a sponsored post. Yes, I am going to mention Global API at the end because they made my life easier. More on that in a bit. Why Image Captioning Was Even on My Radar Our product has a lot of user-uploaded images. Think: product photos, profile pictures, the usual suspects. For each one we need a short, accessible caption that we use for SEO, alt text, and a downstream tagging pipeline. The downstream pipeline, btw, is the part that actually makes us money. Garbage captions in, garbage tags out. We were calling gpt-4o for everything. Every image. No caching. No batching. No thought. Each call cost us $2.50 per million input tokens and $10.00 per million output tokens. You don't have to be a math PhD to know that scales badly. I was not a math PhD. I am still not a math PhD. But I can do division. When I started pulling the numbers, the situation was grim. We were processing roughly 8 million images a month, and each one was generating more tokens than it needed to. I found one image in the logs that had produced a 4,000-token caption. The image was a screenshot of an error message. The caption was longer than the error. The Wake-Up Call: Actually Reading the Catalog One Saturday morning, coffee in hand, I decided to actually look at what was on offer. I'd been ignoring the multi-model world b