标签：#us

Hey everyone! I bring you my development journey on what I have discovered, accomplishments for this...

Don't fight their strength — take away their advantage. Don't fight the boiling water — remove the...

Intro Model providers keep shipping bigger context windows: 100k tokens, 200k, over a...

Previously, I wrote about How I Processed 666K Pages Of Flattened PDFs into a Full Text Search Engine called the Apario writer . Upon on the conclusion of the last segment, I was able to optimize the compilation time of the original collection of data by rewriting the sidekiq Ruby pipeline script into a dedicated Go Application. Regardless of what compiling the PDF assets would look like, I still needed to serve those assets - and that's where the writer did little to nothing to actually address the OPEX of the project from 2020. Given the size of the data set, the 666K pages ended up compiling into a directory of ~1.13TB in size. This was held in storage that was distributed across several high volume storage dedicated servers on OVH behind MinIO . This provided an S3 compatible API directly. What I Know About OPEX OPEX or Op erational Ex pense is how you describe a spending of money that is used explicitly for the operations of the business versus a capital expense. Hardware was considered a CAPEX or Cap ital Ex pense. So when Bit Fry Game Studios needed their DevOps pipeline upgraded for the 9 hour game builds into a 30 minute private enterprise cloud build, it required a CAPEX investment of $69K plus trust in me in order to achieve a -$15K/month OPEX savings. Annualized over a hardware lifecycle, over $472K can be recovered from OPEX by making a small CAPEX expense up front. One of the first projects that I ever worked on was in PHP and MySQL on Ubuntu 8.04 . It was to balance the budget of a department that had ACME Bucks so to speak. It required me to write a finance module, fully tested, that managed Blue , Green and Black dollars. Blue dollars were for OPEX. Green dollars were for CAPEX. Black dollars were for external vendors where money left the company (versus moving between departments). Black depreciated instantly - meaning 100% of it was paid immediately. Blue dollars were borrowed over a 12 month pay-back period. Green dollars were borrowed over a 36

Why Your AI Agent Drowns in 50,000 Tokens of Tool Definitions Every time you connect an MCP server to your AI agent, you're adding thousands of tokens of tool definitions to your context window. Connect 10 servers? That's 50,000 tokens of tool schemas before you've even asked a question. Your agent is drowning in tools it doesn't need. The Problem Traditional MCP integration dumps every available tool into the context: { "tools" : [ { "name" : "file_read" , "description" : "Read a file..." }, { "name" : "file_write" , "description" : "Write a file..." }, { "name" : "shell_exec" , "description" : "Execute shell..." }, // ... 500 more tools ] } Your 200K context window is now 25% full of tool definitions. The model gets confused, response quality drops, and you're paying for tokens that add zero value. The Solution: Progressive Tool Routing HyperNexus implements a multi-layered progressive disclosure system: Semantic Search : Local vector embeddings match your prompt against a global MCP directory The Router : Only the top 3 most relevant tool schemas are injected into context Universal Parity : Byte-for-byte identical tool signatures across Claude Code, Cursor, Codex, Gemini CLI, Copilot, and Windsurf // Only inject what's relevant tools := router . FindRelevantTools ( prompt , 3 ) context . AddTools ( tools ) Results 95% reduction in tool-related context usage 3x improvement in tool selection accuracy Zero hallucinations from irrelevant tool noise Try It Yourself HyperNexus is open source and free for personal use: # Install go install github.com/HyperNexusSoft/HyperNexus@latest # Run hypernexus serve # Connect your MCP servers hypernexus mcp add filesystem hypernexus mcp add github Your AI agent will now only see the tools it needs for each request. This article was originally published on hypernexus.site

Forget YouTube videos—frontier physical AI models need multiple camera angles, dense annotation, and soon, brain wave readings.

Have you ever looked at your raw DNA data from services like 23andMe or Ancestry.com and thought, "What on earth am I looking at?" Behind those megabytes of .txt or .vcf files lies the blueprint of you , but without a PhD in genetics, it's just a wall of "A, C, T, G." In this tutorial, we are going to bridge the gap between raw genomic noise and actionable insights. We’ll build an advanced Genomic RAG (Retrieval-Augmented Generation) pipeline. By the end, you'll have a system that takes raw SNP (Single Nucleotide Polymorphism) data, retrieves clinical significance from the ClinVar database, and generates an interactive risk guide using LlamaIndex and FAISS . If you are interested in Genomic Data Engineering , Bioinformatics with Python , or RAG (Retrieval-Augmented Generation) , this guide is for you. The Challenge: The "Needle in a Haystack" Problem A typical human genome has millions of variants. Most are harmless "junk" DNA, but some are "Pathogenic." Searching for these manually is impossible. We need a system that: Parses massive genomic files efficiently. Indexes trusted medical databases (ClinVar). Matches your specific variants against that knowledge base to provide context. The Architecture 🏗️ Here is how our data pipeline flows from raw pixels (well, raw base pairs) to structured insights: graph TD A[Raw SNP Data / VCF File] --> B(Pandas & Biopython Parser) B --> C{Filter High-Impact Variants} D[ClinVar Clinical Database] --> E(LlamaIndex Indexing) E --> F[FAISS Vector Store] C --> G[RAG Query Engine] F --> G G --> H[LLM: GPT-4o Synthesis] H --> I[Interactive Risk Report] Prerequisites 🛠️ To follow this advanced guide, you'll need: Tech Stack : Python 3.9+, Pandas, LlamaIndex, FAISS, and Biopython. Data : A sample VCF file (you can download public datasets from the 1000 Genomes Project) or your own exported 23andMe data. Step 1: Parsing the Genetic "Nonsense" First, we need to handle the raw data. 23andMe usually provides a tab-separated file. We use Panda

A smart contract can't tell whether a submitted score came from a valid game or was simply made up. Dario Dash handles that by proving the run itself. I have been building Dario Dash , a small endless runner on Dusk. The game runs in the browser and does not require a wallet to play. After a ranked run, the browser can generate a Groth16 proof locally and submit the score to a smart contract. The contract does not trust the submitted score. It accepts it only after verifying the proof, binding it to the transaction sender and checking that the run seed has not already been used. The source is available on GitHub . What actually needs to be proven? A score by itself says almost nothing. A client could simply submit any number it wants. For Dario Dash, a valid run includes much more than the final score: the player movement and jump timing the seed-derived obstacle schedule obstacle clearance and collision windows item pickups damage and game-over conditions fireball kills transitions between Regular, Super, Fire and Cape forms the number of ticks played the resulting score The proof must establish that these rules were followed from the initial state until the claimed final state. It also needs to bind the run to the account submitting it, otherwise somebody could copy another player's proof. The architecture The repository is split into a few layers: dash_zk contains the deterministic game simulation used by the browser proving path. dash_core contains a separate 60 Hz simulation used by the RISC Zero path. dash_web exposes the Rust simulation to the browser through WebAssembly. zk_browser contains the Circom circuit and the JavaScript proof conversion code. contract verifies the proof and maintains the leaderboard on Dusk. web contains the playable Vite application. The important boundary is that the game logic is deterministic and integer-only. Floating point physics would be a mess to reproduce consistently across JavaScript, WebAssembly, the proof circuit and th

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

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

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

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

Hey Techie 🌸 Before I continue my go series, I wanted to share a personal project that I'll be working on alongside my learning. What is IRIS? IRIS is an adaptive accessibility companion meant to help people with invisible disabilities navigate the media in ways preferable to them. Most websites and systems are one-size-fits-all and do not take user preferences into account in depth. The assumption is that every user views technology the same way, and that's not true at all. This is where IRIS shines her glory. The goal of creating IRIS is that it adapts to the user's needs rather than the user adapting to it. She will be able to personalise things like text-to-speech, colour themes, layouts, and other accessibility features based on their needs. As I continue learning Go and backend development, I'll also be sharing the progress of building IRIS, from designing the database and API to developing the backend and, eventually, the complete application. I look forward to sharing my progress and the challenges I will face and having discussions with you, my dear techie friends 🌸

I took a week off from Dev.to. Not a planned one — I just sat down last Sunday and realized I had nothing left. Eighteen stories into a 36-story series, and my tank was empty. So I didn't post a single article for a full week. I'd pop into the comments section now and then, but that was it. The day job was still there, but I stopped staying up till 1:30 AM writing like I did when the series first started. I adjusted to a 10 PM bedtime instead. Then on Friday afternoon, something happened. I spent twenty minutes writing a rant about bugs and layoffs, hit publish, and went back to doing nothing. When I checked back on Sunday, that rant had more eyeballs on it than most of my 36 Stratagems stories. You're supposed to have an existential crisis about your content strategy at this point, right? I didn't. The Series That Wasn't a Strategy Eighteen stories ago, I sat down and wrote the first Stratagem. I wasn't starting from nothing — there was a rough outline in my head, a skeleton of 36 chapters with each of the six characters mapped to a specific stratagem. But I hadn't figured out the details of each story yet. Not because I had a content calendar. Not because an editor was pushing me. Because it clicked. The six protagonists — Derek, Lena, Leo, Alex, Mark, and P — had been living in my head long before the first post went up. They came from an earlier series I'd written, 15 stories about AI systems collapsing in the wild. Those people weren't characters I invented for a series. They were people I'd met, worked with, watched navigate impossible situations. They stayed with me because their stories weren't finished. The 36 Stratagems wasn't a strategy. It was a container. I found an ancient Chinese military text that happened to map perfectly onto what I'd already seen happen in AI engineering teams across the industry. The fit was uncanny — like the text had been waiting two thousand years for someone to rewrite it in Python and production incidents. Each Stratagem too

Hey everyone, I'm Divyanshi! 👋🏻 Can you believe how quickly this year has flown by? It feels like we...

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

Lessons from wrapping grok-build — the architecture, the traps, and why we picked Tauri over Electron. TL;DR grok-build is xAI's open-source Rust coding agent. It ships as a TUI. We wrote a native desktop client for it — Tauri 2 (~8 MB binary), React frontend, Rust runtime that spawns the CLI as a child process and talks to it over ACP/JSON-RPC 2.0. This post is the architecture deep-dive: how the pieces fit together, what surprised us, and the parts we'd build differently next time. The full source is at github.com/timexingxin/grok-gui . MIT-licensed. Demo GIF in the README. The problem grok-build is genuinely good at code work — comparable to Claude Code for my workflow. But it ships as a Rust TUI. After six months of cmd+tab between the terminal and my browser tabs, I wanted a real desktop UX without losing what makes the CLI good. The naive options all had problems: Wrap it as a tmux session in a webview. Doesn't help — you're still reading scrollback. Use a community-built web wrapper. They all wrap the OpenAI Chat Completions API directly. They don't talk to the actual agent runtime, so they miss tool calls, plan updates, permission requests, and the streaming event surface that makes coding agents feel responsive. Write a desktop GUI from scratch. Means re-implementing the agent loop, the model integration, the tool calling. Six months of work, plus the resulting client would always lag the upstream. The right answer was staring at me: grok-build already has a JSON-RPC 2.0 over stdio interface called the Agent Client Protocol (ACP). That's the protocol I should be a client of. My job is just to write the client. What is ACP? ACP is a JSON-RPC 2.0 protocol that coding-agent CLIs expose over their stdin/stdout. The agent emits notifications (text deltas, tool calls, plan updates, permission requests, session lifecycle); the client sends requests (user prompts, permission responses, model switches, session loads). If your agent speaks ACP, you can write a client

Building Astra: A Modern Shell in Rust I've been working on a personal project called Astra , an interactive shell written in Rust. The goal isn't to replace every existing shell overnight. Instead, I'm building a clean, modular foundation that's easy to understand, extend, and contribute to. Some of the features currently in development include: Interactive shell loop Customizable prompt system TOML-based configuration Built-in themes Git-aware prompt Command history Tab completion Alias support Plugin framework (early development) Alongside the shell itself, I'm also putting together the surrounding ecosystem—documentation, packaging, examples, tests, and GitHub automation—so contributors have a solid starting point. This project has been a chance to learn more about Rust, shell design, and how larger open-source projects are organized. It's still early, but it's reached the point where the foundation is in place and I'm beginning to focus on expanding features, improving reliability, and increasing test coverage. Check out the project here: astra-shell / astra-shell A custom shell for mac OS! █████████████░░░░░░░░ 65% Astra Shell A modern shell built in Rust for Unix-like systems, with macOS as the primary development platform. Astra is an interactive command-line environment focused on a clean interface, customization, and a better terminal experience. It combines the power of traditional Unix shells with a modern prompt system, configuration, and extensibility. Warning Astra Shell has not gone through extensive testing yet. Wait until the first stable release before using it as your primary shell. Table of Contents Features Screenshots Installation Requirements Usage Themes Why Astra? Contributing License Status Features Interactive Rust shell Configurable prompt engine Multiple built-in themes Git-aware prompt information Command history Tab completion Alias support TOML configuration Built-in shell commands Modular architecture Plugin framework (in developmen

Google's Vice President of Devices and Services, Shakil Barkat, all but confirmed in an interview with 9to5 Google that its next Pixel phone would cost more than the Pixel 10. Considering the ongoing RAM supply issues due to the explosion of AI data centers, the rumored price hike is not a complete surprise. Companies from […]

In 2017 the National Archives and Records Administration (NARA) released the JFK files in an unsearchable manner 🔍. I tried doing manual research 🕵🏻. I relied on their provided CSV file of metadata to look for relevant documents to discover something - but I was looking for a needle in the haystack. I didn't know where to begin - but at the very least, I wanted to be able to search the contents therein. At least the National Archives allowed me to bulk download the PDFs. From that, I was able to birth the Apario Writer . In 2020, I began with rails new phoenixvault 🐦‍🔥 and I proceeded on a Zoom call with DJ Nicke - a former animator at Disney - to watch me build the proof of concept of the crowd sourcing declass utility that I envisioned. You see, when I was 7 years old, I had a dream after watching a space focused science program on TV that involved me sitting at the home computer, but interacting with an advanced interface that would help me uncover the mysteries of the day and time of the era. In Stargate SG-1, this concept was explored with the Tolan where Nareem was shocked to discover what Teal'c found in the records buried within a full text interface. Connecting it back to the JFK files released by NARA, they were unsearchable. Agenda on why aside, what could I do about it? This proof of concept grew into a SaaS platform that cost me $7,000 per month to operate over 12 bare meta servers in a private cloud using ESXi. This interface worked, but it was going to be replaced by a cost saving solution architected from the ground up in Go to reduce the dependency graph of the SaaS solution down to a single binary . In order to do this, I needed to create a pipeline. Looking at the SaaS model, I had a series of sidekiq jobs that compiled the assets. In order to improve the performance of that process, running off from Ruby code, I needed to build a new binary from the ground up using Go. I took the course on YouTube from Matt Holiday called Programming In Go and wa