标签：#ens

I recently tried to share an open-source project I've been working on called Open Vectorizer . It's a raster-to-SVG vectorization engine written in Rust. It runs locally, compiles to WebAssembly, has a reproducible benchmark suite, and competes surprisingly well with established tools like Potrace and VTracer. I wanted people to see it. More importantly, I wanted contributors. That's where things got weird. First, Hacker News Open Vectorizer felt like a natural fit for Show HN. It's open source. It's technical. There's an interesting algorithm behind it. There are benchmarks people can reproduce and argue about, which I'm told is approximately 73% of Hacker News' renewable energy supply. Except I couldn't submit a Show HN. Hacker News is temporarily restricting Show HN submissions from newer users because of a large influx of people unfamiliar with the community. Fair enough. Annoying, but understandable. So I tried Reddit. Then r/rust Open Vectorizer is written in Rust, so r/rust seemed like an even more obvious place to share it. The post was automatically removed. The subreddit now requires project submissions to certify that they do not contain significant AI-generated content . And that's something I can't honestly certify. Open Vectorizer has been developed with substantial AI assistance. So I didn't repost it. Then r/opensource Surely an MIT-licensed project actively looking for contributors belongs in an open-source community. Their rules include: All AI-generated content is low-effort and ban worthy. At this point I had to appreciate the situation. I had an open-source project. I wanted humans to contribute to it. And some of the communities containing exactly those humans didn't want me to tell them about it because machines had helped write it. Here's the problem I actually understand why these rules exist. AI has made it incredibly cheap to produce software-shaped objects. You can ask an agent to build a database, publish 20,000 lines to GitHub an hour l

A while back I built a small tool called SDKProof. it checks how well an AI coding agent writes an SDK's current API — the stuff that changed in the last major, that the model tends to get wrong because it learned the old version. Claude Opus 5 came out today. so I re-ran the whole board on it. short version: it fixed last year's SDKs. it did not fix this year's. The board, now on Opus 5 Same tasks, same libraries, new model: SDK shipped its major Opus 5 Prisma 7 late 2025 (freshest) 87 Next.js 16 late 2025 92 Vercel AI SDK 7 mid 2025 100 Zod 4 2025 100 TanStack Query 5 2023 100 The way each score works: the model solves ~10–15 real tasks, the code gets type-checked against the real installed package, pass = it compiles. no LLM judging another LLM, the compiler decides. The two that jumped: Vercel AI SDK 7 and Zod 4 were both 90 on the previous model (Opus 4.8). Opus 5 took them to 100. What flipped Here's the kind of thing that changed. Define a tool with the AI SDK. Opus 4.8 wrote it the old (v4) way: const getWeather = tool ({ parameters : z . object ({ city : z . string () }), // renamed to inputSchema execute : async ({ city }) => `...` , }) await generateText ({ model , prompt , tools : { getWeather }, maxSteps : 5 , // removed }) That doesn't compile against ai v7. parameters is now inputSchema , and maxSteps is gone (it's stopWhen: stepCountIs(5) now). Opus 5 writes the current shape by itself: const getWeather = tool ({ inputSchema : z . object ({ city : z . string () }), execute : async ({ city }) => `...` , }) await generateText ({ model , prompt , tools : { getWeather }, stopWhen : stepCountIs ( 5 ), }) Clean compile. same for Zod — Opus 4.8 kept reaching for the removed required_error , Opus 5 writes the new unified error option. What didn't move Prisma 7 and Next 16 barely changed. they shipped their breaking changes most recently, and even the newest model hasn't caught up. Prisma still writes the pre-v7 client setup — it skips the driver adapter that

How to Build and Debug MCP Servers for Claude Desktop in 5 Seconds 🔨 Model Context Protocol (MCP) by Anthropic is rapidly becoming the open standard for connecting LLMs like Claude Desktop, Cursor, and Windsurf to local dev tools, APIs, and databases. However, setting up an MCP server from scratch, configuring stdio transports, and debugging JSON-RPC requests in the terminal can be tedious. To solve this, I built mcp-forge — an open-source Swiss-Army developer toolkit and inspector for MCP servers. ⚡ What is mcp-forge ? mcp-forge gives you everything you need to build, test, inspect, and run MCP servers with zero setup overhead : 🛠️ npx mcp-forge serve : Launches a built-in suite of developer tools for Claude Desktop (Git summary, System diagnostics, Mermaid syntax validator, HTTP API tester). 🔍 npx mcp-forge inspect <cmd> : An interactive stdio inspector to connect to any MCP server, list tools/resources/prompts, and test executions live. ⚡ npx mcp-forge init <name> : Scaffolds a production-ready TypeScript MCP server in 5 seconds with TypeScript, tsup bundler, and Vitest. 🌐 npx mcp-forge ui : A visual dark-themed web dashboard for real-time WebSocket traffic monitoring. 🚀 Quickstart: Supercharge Claude Desktop in 1 Minute You don't even need to install anything globally! You can run mcp-forge directly via npx . 1. Add mcp-forge to Claude Desktop Add this snippet to your claude_desktop_config.json : { "mcpServers" : { "mcp-forge" : { "command" : "npx" , "args" : [ "-y" , "mcp-forge" , "serve" ] } } } Now Claude can automatically inspect your Git status, fetch system memory/CPU telemetry, validate Mermaid diagram syntax, and test REST endpoints! Scaffold a New MCP Server in 5 Seconds Want to build your own custom MCP server? Run: npx mcp-forge init my-awesome-mcp-server cd my-awesome-mcp-server npm install npm run dev You get a fully-typed MCP server template with @modelcontextprotocol/sdk configured and ready to publish. Inspect & Debug Any MCP Server in Terminal N

Most agent frameworks help you build a workflow. The harder part starts after that: the workflow has to run as a long-lived process, fail clearly, restart carefully, and be inspectable after the fact. That's the gap I'm building AgentOS for — an open-source, Rust-first runtime layer that sits underneath frameworks like LangGraph, AutoGen or CrewAI instead of replacing them. What one process gives you cargo run -p agentos-cli -- run --agent examples/simple_agent.toml That single command brings up a supervised agent, a health endpoint, a gRPC message bus, a live SSE event stream, and a recorded trace you can replay later. No API key is needed just to bring the runtime up. Time-travel debugging Your agent does something weird on step 7. Reproducing it costs real API calls, and it never behaves the same way twice. AgentOS journals every LLM exchange and tool result at the provider boundary, so any run can be replayed deterministically — and forked into alternate timelines: agentOS run --agent my_agent.toml # every step journaled automatically agentOS replay --session agent_123 # offline re-run, no API cost, drift-checked agentOS fork --from ckpt_4 --prompt "try the other path" The dashboard's Recordings view turns those journals into a scrubbable timeline: step through the prompt, each exchange, tool calls and their results, with per-exchange checkpoints as fork anchors. What's inside crates/kernel — lifecycle, agent handles, supervisor crates/bus — in-memory, gRPC, SSE and WebSocket messaging crates/trace — recording, replay, diff, checkpoint model crates/vault — secret isolation, encryption, scopes, audit crates/memory , crates/registry , crates/llm , crates/cli , crates/sdk dashboard/ — React debugging surface Where it honestly stands Stable enough for local use: the run / ps / logs / trace / replay CLI flows, local state inspection, export and import, and the core crates with workspace checks and tests. Still experimental: the dashboard, the WASM plugin runtime, Doc

I spent a week trying to answer one question about my own AI agents: when one of them does something stupid in production, how do I prove the fix worked? For normal software the answer is boring. You have monitoring, an incident, a regression test, a staged rollout. For an agent you usually have a trace viewer and a shrug. So I built ArcNet on self-hosted SigNoz for the Agents of SigNoz hackathon, and most of what I learned was about SigNoz internals I could not have guessed from the docs. Here are the parts that cost me real time. The setup The stack is small. Agents run on Agno. An in-process SDK wraps them and does two jobs: OpenTelemetry instrumentation, and guardrails from unplug-ai at four checkpoints (input, retrieved content, tool call, output). Traces go to self-hosted SigNoz over OTLP. A FastAPI server reads back out of SigNoz, and a React UI sits on top. Installing SigNoz was the easiest part, which surprised me. Foundry takes one file: apiVersion : v1alpha1 kind : Installation metadata : name : signoz spec : deployment : flavor : compose mode : docker signoz : spec : image : signoz/signoz:v0.133.0 foundryctl cast -f casting.yaml That brings up SigNoz and its MCP server together and writes a casting.yaml.lock with checksums. I committed the lock file, and re-running foundryctl forge against it later produced a byte-identical file. That is a genuinely nice property for a hackathon judge or a teammate. Lesson 1: check what your instrumentor actually emits This is the one I would tell everyone. I assumed Agno instrumentation would produce OpenTelemetry's gen_ai.* semantic conventions, because that is what the GenAI spec describes. I started sketching dashboard queries against gen_ai.usage.input_tokens before anything was running. Then I turned it on. openinference-instrumentation-agno emits OpenInference conventions, which are a different attribute set. The spans I actually got were shaped like this: agent_j.run └── gpt-5.6-luna.invoke └── search_tickets Eve

Let me start with a question. If a stranger handed you a USB drive and said "plug this in, it just...

Most AI diagram workflows end with a PNG or a screenshot. It may look fine, but the moment the architecture changes, you have to redraw it or regenerate the whole image. I wanted a different workflow: describe a system in natural language, receive a real Draw.io file, and keep editing every node, label, connector, group, and icon. That is why I built drawio-mxgraph , an open-source Codex Skill that turns architecture and process descriptions into validated, editable .drawio files. Repository: https://github.com/clawcode3-bit/drawio-mxgraph-skill What the Skill does The Skill generates mxGraph XML that opens directly in Draw.io/diagrams.net. It is designed for architecture diagrams, business processes, agent workflows, and integration maps. Key capabilities include: Natural-language descriptions to editable .drawio XML Stable node IDs for reliable incremental updates Add, remove, move, resize, rename, and regroup operations Layout direction switching: left-to-right, right-to-left, top-to-bottom, or bottom-to-top Orthogonal connector routing with explicit entry and exit points Portable embedded SVG icons, including cloud and enterprise-style icon sets XML structure and reference validation before delivery Example diagrams that can be opened and modified immediately Why stable IDs matter A common failure mode in generated diagrams is treating every edit as a full redraw. That makes small requests surprisingly destructive. With stable IDs, a request such as: Move the ticketing system below the CRM, add an observability group, and change the layout to left-to-right. can update only the affected cells. Existing labels, styles, icons, connections, and manually adjusted positions can remain intact. This makes the diagram behave more like source code than a disposable image. Example: an AgentBuilder customer-service architecture The repository includes an editable example for an intelligent customer-service system built with AgentBuilder. It connects: Web, mobile, messaging,

GitHub热门项目 | The Cyber Swiss Army Knife - a web app for encryption, encoding, compression and data analysis | Stars: 35,443 | 77 stars this week | 语言: JavaScript

GitHub热门项目 | Simple, Fast, Code first and Compile time generated OpenAPI documentation for Rust | Stars: 3,983 | 8 stars today | 语言: Rust

GitHub热门项目 | You're the boss, agents are your team. They handle tasks on their own, message each other, and review each other's work. You just watch the kanban board and give high-level commands. Codex/Claude/OpenCode/Cursor/Grok/GitHub Copilot/Kiro/Z.AI/MiniMax/Kimi(200+ models, 75+ LLM providers, free models no auth). Build your AI company with multiple teams | Stars: 1,680 | 23 stars today | 语言: TypeScript

GitHub热门项目 | A progressive Node.js framework for building efficient, scalable, and enterprise-grade server-side applications with TypeScript/JavaScript 🚀 | Stars: 76,210 | 15 stars today | 语言: TypeScript

GitHub热门项目 | Free AI with your ChatGPT account | Stars: 933 | 109 stars today | 语言: TypeScript

GitHub热门项目 | MCP servers for the UniFi suite of applications, Network, Protect, Access, and Drive | Stars: 579 | 14 stars today | 语言: Python

GitHub热门项目 | 🔥🔥🔥 AI-driven database tool and SQL client, The hottest GUI client, supporting MySQL, Oracle, PostgreSQL, DB2, SQL Server, DB2, SQLite, H2, ClickHouse, and more. | Stars: 26,906 | 399 stars today | 语言: Java

Hey folks 👋 If you've ever wanted to save a video lecture, a livestream replay, or a podcast episode for offline listening, you've probably run into the usual options: sketchy "online video parser" websites that ask you to paste your link into their server, or desktop apps that want you to sign up and upload stuff. Neither feels great when the whole point is your content. I went looking for something better and ended up working with FlowPick — an open-source, privacy-first media downloader that runs entirely in your browser. No uploads, no accounts, no telemetry. Everything (sniffing, downloading, merging, transcoding) happens client-side with FFmpeg compiled to WebAssembly. In this tutorial we'll: Clone and run FlowPick locally Download our first HLS ( .m3u8 ) and DASH ( .mpd ) stream Build and deploy it Poke at the internals so we can customize it If you just want to try it without installing anything, there's a hosted version at https://flowpick.net (more below). The full source is on GitHub: https://github.com/ezwebtools/flowpick . 🔗 Repo: https://github.com/ezwebtools/flowpick · Live tools: https://flowpick.net A 30-second primer: what are HLS and DASH? Before we touch code, two words you'll see everywhere in this space: HLS (HTTP Live Streaming) uses a .m3u8 manifest that lists small .ts (or fMP4) segments. Common for live streams and a lot of video platforms. DASH (Dynamic Adaptive Streaming over HTTP) uses a .mpd manifest; video and audio usually travel as separate .m4s tracks. YouTube and Bilibili lean on this. The key idea: the "video" isn't one file. It's a playlist pointing at dozens (sometimes hundreds) of tiny segments. A downloader's job is to fetch all the segments, decrypt them if needed, and stitch them back into one playable file. That's exactly what FlowPick does — in the browser. What FlowPick is, in one paragraph FlowPick is a Nuxt 4 app that ships in two shapes: A browser extension that sniffs media from the current tab's network requests. An

Nobody has ever asked you to upstream your dotfiles. For thirty years that was the deal with every tool we touched: if you didn't like it, you changed it, and the change lived with you. Then the tools started writing the code, and the deal quietly ended. This essay is about why the deal is back on the table. Because the thing that used to make forking expensive — the labour — is exactly what agents just made cheap. In This Article The Workbench Instinct Then the Harness Era Arrived Forking Was Always the Escape Hatch Code Got Cheap What I Shipped Into My Fork A Feature Does Not Have to Be Useful Your Desire Is the Limit The Fork Is the Destination Now the Discipline Part Bring Back the Joy The Workbench Instinct Show me a developer who has never touched their config and I'll show you someone who hasn't started yet. Vim users brag about their init.lua the way woodworkers talk about a hand plane they've had for twenty years. Emacs people wrote a whole operating system inside a text editor because they could. VS Code won partly because it shipped an extension API and got out of the way. Dotfiles repos are public artifacts, starred and forked, because the setup is part of the craft. This isn't productivity theatre. Some of it is genuine need, some of it is fixing a specific annoyance that only you have, and a lot of it is just fun. All three are valid. The workbench is where the joy lives — and nobody ever waited for permission to alias a command. Then the Harness Era Arrived Then agentic coding tools showed up and quietly changed the shape of the deal. The best-in-class agent harnesses are increasingly vendor-controlled. Claude Code is a product, not a repo you can clone and rebuild. Google announced it's retiring Gemini CLI in favour of a closed-source successor. And note where the line falls: Codex CLI is Apache-2.0 and sitting right there on GitHub, but the Codex desktop app — the thing most people actually click on — is not. The terminal stayed open. The interface

Video transitions are one of those details that quietly shape the feel of an edit. In Reel Quick issue #13 , the goal was simple: let users control how long a scene transition lasts instead of forcing a fixed value. Issue URL: https://github.com/ronin1770/reel-quick/issues/13 The problem The app already supported transition effects between scenes, but the duration was fixed. That meant creators could choose what transition to use, but not how long it should run. For short-form video, that matters a lot: fast transitions create a snappier pace longer transitions feel smoother or more cinematic some edits need no transition at all The feature The new behavior adds a configurable transition duration: minimum: 0.0 seconds maximum: 4.0 seconds step: 0.5 seconds A slider in the frontend lets the user choose the duration, and that value is sent to the backend for FFmpeg video generation. If the value is 0.0 , transitions are disabled entirely. The FFmpeg math When two clips are joined with a transition, the transition overlaps the end of the first clip and the start of the second clip. So the final duration is: final length = clip 1 + clip 2 - transition duration Example 1 Clip 1 = 7 seconds Clip 2 = 8 seconds Transition duration = 4 seconds Math: 7 + 8 - 4 = 11 seconds Final video length: 11 seconds Example 2 Clip 1 = 7 seconds Clip 2 = 8 seconds Transition duration = 0.5 seconds Math: 7 + 8 - 0.5 = 14.5 seconds Final video length: 14.5 seconds Why validation matters This feature also needs guardrails. The backend validates that: the duration is between 0 and 4 the duration is a multiple of 0.5 clips are long enough for the selected transition That last point is important. A 4 second transition cannot work safely if a clip itself is only 3 seconds long. Implementation notes The implementation touches both frontend and backend: Frontend add a transition duration slider show the selected value beside it send transition_duration in the video creation request show inline vali

Most MCP servers I see in the wild start as a quick script and stay that way — no validation, no structured logging, no tests, and a deploy story that means shipping node_modules around. I got tired of rebuilding the same scaffolding every time a client project needed a Model Context Protocol server, so I open-sourced the template I now start every one from: 🚀 mcp-server-template It's a production-ready TypeScript/Node.js foundation for building MCP servers that connect AI agents like Claude Desktop and Cursor to your tools, data, and workflows. 𝗚𝗲𝘁𝘁𝗶𝗻𝗴 𝘀𝘁𝗮𝗿𝘁𝗲𝗱 𝘁𝗮𝗸𝗲𝘀 𝗳𝗼𝘂𝗿 𝗰𝗼𝗺𝗺𝗮𝗻𝗱𝘀: git clone https://github.com/qmmughal/mcp-server-template.git cd mcp-server-template && npm install cp .env.example .env npm run dev That spins up a working server in watch mode. npm test runs the Vitest suite, npm run build bundles everything into a single dist/index.js with esbuild — no node_modules to deploy. 𝗪𝗵𝗮𝘁 𝗮 𝘁𝗼𝗼𝗹 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗹𝗼𝗼𝗸𝘀 𝗹𝗶𝗸𝗲: Every tool gets a Zod schema, a definition, and a handler — so a malformed AI payload gets rejected with a clean error instead of crashing your process: const schema = z . object ({ text : z . string (). describe ( " The text to process " ), repeat : z . number (). int (). min ( 1 ). max ( 10 ). optional () }); export async function handleExampleTool ( args : unknown , service : ExampleService ) { return withErrorHandling ( " process_text " , async () => { const { text , repeat } = validateArgs ( schema , args ); const result = await service . processText ( text , repeat ); return { content : [{ type : " text " , text : result }] }; }); } 𝗘𝘅𝘁𝗲𝗻𝗱𝗶𝗻𝗴 𝗶𝘁 𝗳𝗼𝗿 𝘆𝗼𝘂𝗿 𝗼𝘄𝗻 𝘁𝗼𝗼𝗹𝘀: Drop a new file in src/tools/ following the same schema → definition → handler shape Register it in src/tools/index.ts — add your definition to the tools list and a case to the switch statement that routes CallToolRequest to your handler Put your real logic in src/services/ so the protocol layer stays thin and your business logic stays unit-testable in isolation Resources (data the

When Your AI Code Reviewers Disagree: Inside the 'AI Debate' That Finds Hidden Bugs Discover how a new paradigm of code review automation pits two AI agents against each other in a structured AI debate, using agent consensus to uncover nuanced bugs that single-agent systems miss. See a real example of AI pair review in action. The End of the Single Perspective Code Review Traditional automated code review tools often operate from a single, deterministic rule set. They flag violations of style guides, potential security flaws, or common anti-patterns with a yes/no verdict. But this approach fundamentally misses the nuance of software development: context. Is a seemingly risky pattern actually a carefully considered workaround? Is a deviation from the norm a brilliant optimization or a latent bug? This is where the old paradigm fails, treating code as static text rather than a dynamic system of intent and consequence. Imagine a different approach. Instead of one monolithic AI passing judgment, what if you deployed two specialized AI agents to review the same code change? Their core directive: engage in a rigorous, technical **AI debate**. One agent is programmed to be a strict adherent to best practices and correctness. The other is trained to understand historical code patterns, developer intent, and often-overlooked performance trade-offs. This is the foundation of **AI pair review**, a method that moves beyond simple flagging and into the realm of collaborative analysis. The Scenario: A Performance Bottleneck with a Catch Let's examine a concrete example. A developer submits a change to a data processing pipeline in a Python application. The core function now includes a caching layer to avoid redundant, expensive database calls. The code change looks clean at first glance. def process_user_data(user_ids): # Cache to avoid repeated DB hits for the same ID in a batch user_cache = {} results = [] for uid in user_ids: if uid not in user_cache: # Simulate an expensive D

Let’s be honest: manual diet tracking is a chore that almost nobody finishes. We start with good intentions, but typing "150g of grilled chicken" and "half a cup of brown rice" into an app every day is a recipe for burnout. But what if you could just snap a photo and let Multimodal AI do the heavy lifting? 📸 In this tutorial, we are building a production-ready automated nutrition logging system. We will combine the surgical precision of the Segment Anything Model (SAM) with the reasoning power of GPT-4o Vision . By the end of this post, you'll know how to transform raw pixels into a structured JSON of calories, macros, and portion sizes using FastAPI and Pydantic . We'll cover key concepts in Image Segmentation , Computer Vision , and LLM Structured Outputs . The Architecture: From Pixels to Proteins To get accurate results, we can't just toss a messy photo at an LLM and hope for the best. We need a pipeline that identifies individual food items, isolates them, and then performs a multi-step inference. graph TD A[User Uploads Food Image] --> B[FastAPI Backend] B --> C[SAM: Segment Anything Model] C --> D[Generate Individual Food Masks] D --> E[GPT-4o Vision: Multi-crop Analysis] E --> F[Pydantic Validation] F --> G[Structured Nutrition Report] G --> H[User Dashboard] Prerequisites To follow along, you'll need: Python 3.10+ OpenAI API Key (with GPT-4o access) FastAPI & Uvicorn (for the web layer) Segment Anything Model (SAM) weights (or a hosted inference API) Step 1: Defining the Nutrition Schema The secret to a reliable AI system is Structured Output . We don't want a "chatty" response; we want data our database can consume. We'll use Pydantic to define exactly what a "Meal" looks like. from pydantic import BaseModel , Field from typing import List class FoodItem ( BaseModel ): name : str = Field ( description = " Name of the food item " ) estimated_weight_g : float = Field ( description = " Weight in grams " ) calories : int = Field ( description = " Total calorie