标签：#rag

Claude LLM Execution Harnesses, RAG Rerank, & Browser-based Edge AI Today's Highlights This week's top stories delve into advanced LLM orchestration with Anthropic's execution harnesses, highlight rerankers as a critical RAG pipeline upgrade, and explore practical browser-based AI for sign language recognition without cloud dependencies. Anthropic Explains How Claude Builds Its Own Execution Harnesses (InfoQ) Source: https://www.infoq.com/news/2026/06/claude-code-harnesses/?utm_campaign=infoq_content&utm_source=infoq&utm_medium=feed&utm_term=global This InfoQ article provides a deep dive into Anthropic's sophisticated orchestration system designed for managing multi-step processes with large language models (LLMs) like Claude. It details how the AI company constructs "execution harnesses" that enable Claude to chain together various operations, handle complex tasks, and recover from errors, going beyond simple prompt-response interactions. The system effectively functions as an internal agentic framework, showcasing advanced patterns for LLM workflow automation and robust production deployment. Understanding these internal mechanisms offers valuable insights for developers and architects aiming to build more resilient and capable AI agents that can tackle intricate, real-world workflows, from dynamic task planning to adaptive execution. It highlights the importance of modularity, self-correction, and tool integration in scaling LLM applications for enterprise use, providing a blueprint for building sophisticated AI agent orchestration layers. Comment: This is a fantastic look behind the curtain at how a leading LLM provider tackles agent orchestration at scale. It underscores that robust LLM applications require sophisticated workflow management, not just better models. RAG Rerank: the Highest-Leverage Upgrade to Your Retrieval Pipeline (Dev.to Top) Source: https://dev.to/dev48v/rag-rerank-the-highest-leverage-upgrade-to-your-retrieval-pipeline-7o5 This Dev.to artic

Pipeline & Prompts | Byte size guides on DevOps, Cloud and AI AI in the Stack #2 ⚡ Byte Size Summary RAG inserts a retrieval layer between your existing runbooks and an LLM — answers come from your documentation, not generic training data, with source citations included. This article builds a complete FastAPI service with /ingest , /query , and /health endpoints, using OpenAI embeddings and Chroma as the vector store. Everything is cloneable from GitHub. The goal is not to replace your runbooks. It is to make them queryable at the moment an incident is happening. I have never met a platform team with bad runbooks. I have met plenty of platform teams where the runbooks exist, are reasonably well written, are stored somewhere sensible — and are still completely useless at 2am when something is on fire. Not because the content is wrong. Because nobody can find the right one fast enough. The search in Confluence returns fourteen results and none of them are titled the way the engineer is thinking about the problem. The person on call is junior and doesn't know the runbook exists. The runbook was written for a slightly different version of the service and nobody updated it. The runbook problem is not a writing problem. It is a retrieval problem. That is exactly the problem RAG was built to solve — and it is one of the highest-ROI first applications of AI in a platform engineering context. Not because it is technically impressive. Because it closes a gap that costs your team hours every month. This article builds a working pipeline. By the end you will have a FastAPI service that takes a natural language question — "why is my pod stuck in CrashLoopBackOff after a config change?" — and returns an answer grounded in your actual runbooks, with the source document cited. Everything is in the GitHub repo agentic-devops What RAG Is — Without the Hype RAG stands for Retrieval-Augmented Generation. Instead of asking an LLM a question and hoping its training data contains the answ

Optimizing RAG Pipelines, Migrating AI Agents, and LLM-Powered Troubleshooting Today's Highlights This week's highlights cover advanced strategies for building and maintaining robust AI systems, from fine-tuning RAG pipelines to orchestrating agent migrations. We also explore practical, real-world LLM application in IT operations. A Cognitive Benchmark for Code-RAG Retrieval: Part 2 — Why Model Rankings Depend on the Pipeline (Dev.to Top) Source: https://dev.to/miftakhov/a-cognitive-benchmark-for-code-rag-retrieval-part-2-why-model-rankings-depend-on-the-pipeline-12a4 This article delves into the critical but often overlooked aspect of RAG (Retrieval Augmented Generation) performance: how the entire pipeline, not just the underlying LLM, dictates retrieval efficacy, especially in code-RAG scenarios. It introduces a cognitive benchmark for code retrieval, moving beyond simple keyword matching to evaluate how well a RAG system understands developer intent when querying unfamiliar codebases. The core insight is that model rankings are highly dependent on the complete RAG pipeline design, including chunking strategies, embedding models, and retrieval algorithms, rather than solely on the base LLM's capabilities. For developers building code-centric RAG applications, this implies a need for holistic pipeline optimization. The article emphasizes that focusing on individual components in isolation may lead to suboptimal results. It encourages a structured approach to benchmarking that reflects real-world developer queries and challenges, such as understanding system behavior rather than just file names. This technical perspective is crucial for anyone looking to deploy robust and performant RAG systems for code generation, search augmentation, or automated code understanding. Comment: This is a crucial read for anyone moving beyond basic RAG demos. It highlights that success in production RAG systems, particularly for code, is all about the pipeline engineering , not just

"Chat with your PDF / your notes / your docs" is everywhere. Today we build it from scratch and you'll see it's just three moves : retrieve, then generate — with one prompt trick that stops the hallucinations. This is Day 46 of TechFromZero. Yesterday (Day 45) we built the retrieval half with pgvector. Today we add the answer half and host it on Supabase. RAG in one line Find the relevant chunks of your documents, paste them into the prompt, and tell the model to answer using only those. That's Retrieval-Augmented Generation. The "augmented" part is just stuffing real context into the prompt so the model isn't guessing from memory. 1. Storage: Supabase is Postgres, so pgvector is one click Supabase is hosted Postgres with an auto-generated API. Because it's just Postgres , vector search needs no separate database: create extension if not exists vector ; create table documents ( id bigserial primary key , content text , embedding vector ( 384 ) ); -- one RPC the app calls to get the closest chunks create function match_documents ( query_embedding vector ( 384 ), match_count int ) returns table ( id bigint , content text , similarity float ) language sql stable as $$ select id , content , 1 - ( embedding <=> query_embedding ) as similarity from documents order by embedding <=> query_embedding limit match_count ; $$ ; 2. Ingest: chunk → embed → store Split your docs into paragraph-sized chunks, embed each with a free local model (all-MiniLM-L6-v2 via Transformers.js — no key, nothing leaves your machine), and insert the row + vector: const embedding = await embed ( chunk ); // 384 numbers await supabase . from ( " documents " ). insert ({ content : chunk , embedding }); Chunk size matters: too big buries the answer in noise, too small loses meaning. A few hundred characters is a good start. 3. Retrieve + Generate (the payoff) Embed the question with the same model, ask Supabase for the closest chunks, then hand them to the LLM: const query_embedding = await embed ( que

Extends an earlier model-selection benchmark to three model families (Japanese / Western / Chinese) on a Japanese RAG task. Repo + raw results: https://github.com/elvisyao007/eval-driven-llm/tree/main/reports/model-selection-v2 An earlier post benchmarked local models for a Japanese RAG task and settled on selecting by constraint rather than raw capability. This post widens the field to three families — Japanese-tuned, Western open, and Chinese — and the result forces a distinction that matters more than any single score: model capability and deployment eligibility are two different questions, and conflating them is how people get model selection wrong. Same Japanese RAG task, same judge protocol, same discriminating golden set (oracle 87.5%, only 11% of questions answered by all models — it actually separates the field). hit@5, 8B class unless noted: Model Family hit@5 Swallow-8B Japanese-tuned ~0.53 Nemotron-9B-JP Japanese-tuned ~0.62 ELYZA-JP-8B Japanese-tuned ~0.40 deepseek-r1-8b Chinese ~0.51 Llama-3.1-8B Western ~0.22 Mistral-7B Western ~0.18 gemma4-31b Western (31B) ~0.62 Three things fall out of this, and they don't all point the same direction. 1. At 8B, Japanese fine-tuning is decisive — and generic Western models just aren't competitive The Western 8B models cratered: Llama-3.1-8B at 0.22, Mistral-7B at 0.18, against a Japanese-tuned average around 0.52. That's not a small gap; it's the difference between usable and not. This answers a question people sometimes ask skeptically — why do Japanese-specific models exist when Llama is right there? At the 8B scale, on a Japanese retrieval-grounded task, a generic Western model without Japanese fine-tuning is not in the running. The Japanese tuning is doing decisive work. One honest qualifier on the table: gemma4-31b (0.62) is the one Western model that holds up — but it's 31B, not 8B. It earns its score with 4× the parameters, not with Japanese optimization. So read the table in two tiers: within the 8B class,

Most RAG demos answer "what's the right chunk?" Very few can answer the two questions a regulator or an auditor will actually ask: Replay this decision — show me the exact, complete record of how this answer was produced. Reconstruct the past — what did your system know at the moment it answered, not what it knows now? I got tired of hand-waving at both, so I shipped two pre-registered, deterministic benchmarks alongside JAMES , my local-first, audit-native Graph-RAG. Pre-registered means the metrics, scenarios, and decision rules were locked before the numbers came in — no post-hoc story-fitting. RAB — Replayable-Audit Benchmark RAB measures whether your audit trail is good enough to replay a decision, with three deterministic metrics: Metric What it checks EU AI Act AC — Audit Completeness Is every decision-relevant event logged? Art. 10 RF — Replay Fidelity Can you re-derive the answer from the log alone? Art. 12 PC — Provenance Coverage Does every claim trace to a source? Art. 19 The three metrics map verbatim to EU AI Act Articles 10, 12, and 19 — record-keeping obligations that apply from 2026-08-02 (per Article 113). Scenario S1 result: AC RF PC JAMES 1.000 1.000 1.000 Baseline-0 0.275 0.000 0.000 (vanilla default-logging) The gap is the whole point. "We have logs" (AC 0.275) is not the same as "we can replay the decision" (RF 0). Default application logging gets you a partial event trail and zero replay/provenance — which is exactly the failure mode an Article 12 audit would surface. LRB — Lifecycle Retrieval Benchmark RAG facts go stale. A policy is superseded, a price changes, a spec is revised. LRB asks: when you query as of a point in time, do you retrieve the fact that was valid then , or whatever overwrote it? Three systems compared: V — Vanilla : no time handling. N — Naive-supersede : newest fact wins. J — JAMES : validity-window retrieval ( reconstruct_graph_at(t) ). The R@1 ordering V < N < J holds across 4 model families × 4 scale points (a 12.5×

AI Agents Level Up Workflows: Terraform MCP, WebMCP, Pinecone Integrations Today's Highlights This week showcases significant advancements in AI agent orchestration and workflow automation, with new tools enabling AI to manage infrastructure, interact with the web, and leverage enterprise data. These developments highlight the growing maturity of applied AI frameworks for real-world production use cases. Terraform MCP Server Enables AI Assistants to Interact with Terraform Infrastructure (InfoQ) Source: https://www.infoq.com/news/2026/06/terraform-mcp-server-ga/?utm_campaign=infoq_content&utm_source=infoq&utm_medium=feed&utm_term=global The Terraform MCP (Machine Code Platform) Server has recently achieved general availability, marking a significant step forward in the integration of AI assistants with infrastructure-as-code paradigms. This new server allows AI agents to directly interpret and execute operations on Terraform-provisioned infrastructure, providing a robust and standardized interface for AI-driven automation. Instead of relying on complex scripting or indirect API calls, AI assistants can now receive natural language instructions, translate them into appropriate Terraform commands, and manage resources like virtual machines, networks, and databases across various cloud providers. This capability introduces unprecedented potential for advanced workflow automation within DevOps environments. Teams can leverage AI for tasks ranging from autonomous resource provisioning based on demand surges to intelligent incident response that dynamically scales or reconfigures infrastructure. The MCP Server acts as a crucial middleware, ensuring secure and controlled interaction between intelligent agents and critical infrastructure, thereby reducing manual operational burdens and enhancing system resilience through automated, intelligent responses. This direct interaction paves the way for a new era of self-managing, AI-orchestrated cloud environments. Comment: This i

When people say they are "adding RAG" to a workflow, the conversation often jumps too quickly to infrastructure choices. Should this use a vector database? Should there be a reranker? Should everything go into a knowledge graph? Those are valid questions, but they are usually not the first question. The first question is narrower: What approved knowledge should the workflow be allowed to retrieve before an AI decision happens? That is why my first retrieval layer for operational AI workflows starts in Postgres, not in a standalone vector database. The Workflow Problem In operations-heavy systems, the model usually should not answer from raw memory or from a giant prompt dump. The useful context already exists somewhere else: approved response rules; handoff criteria; product or service notes; source or campaign guidance; operational decisions that were already made by humans. The hard part is not generating fluent text. The hard part is retrieving the right approved context, showing which source influenced the decision and refusing when no safe source exists. Why Postgres First For this kind of workflow, most of the surrounding data is already relational: leads or conversations; workflow names; stages and owners; human review outcomes; source metadata; trace logs; document versions. So the first technical choice is not "where do vectors live in the abstract?" It is: Where can I keep retrieval close to the operational data model? Where can I log the retrieval path and the final decision together? Where can I evolve the schema without creating a second system too early? Postgres plus pgvector is a good first answer to that set of questions. It lets me keep: documents and chunks; metadata such as allowed use and approval requirements; retrieval traces; cost estimates; human review outcomes in one place. What The First Version Needs The first version does not need to be broad. It needs to be inspectable. My narrow retrieval scope looks like this: approved response rules

Local AI Coding Agents, Secure Production Deployment, and Angular-Specific AI Skills Today's Highlights This week's top stories highlight practical ways to deploy and secure AI agents, from setting up local coding assistants on macOS to sandboxing untrusted agent code in Azure, alongside new resources to improve AI-generated code quality for Angular. How to setup a local coding agent on macOS (Hacker News) Source: https://ikyle.me/blog/2026/how-to-setup-a-local-coding-agent-on-macos This guide provides a step-by-step tutorial on deploying and configuring an AI coding agent directly on a macOS system. The process typically involves setting up a local Large Language Model (LLM) or connecting to a local inference engine, integrating it with an orchestration framework, and configuring it to interact with local development tools and environments. The emphasis is on enabling developers to have a private, customizable AI assistant for code generation, debugging, and project scaffolding without relying on external cloud services. This local setup is crucial for privacy-conscious developers and for those who want to fine-tune agent behavior for specific internal codebases. The article likely covers prerequisites such as Python environments, relevant libraries, API key management for local models (if applicable), and how to set up the agent to execute code within a sandboxed environment on the machine. It offers a practical pathway for developers to experiment with AI agents in their daily coding workflows, providing immediate utility and control over the AI's operations and data handling. Comment: This is a great hands-on guide for anyone wanting to run AI coding agents locally, which is essential for privacy and custom development workflows. Run Untrusted AI Agent Code Safely with Azure Container Apps Sandboxes (InfoQ) Source: https://www.infoq.com/news/2026/06/untrusted-ai-agents-sandboxes/ Microsoft has announced the public preview of Azure Container Apps Sandboxes, a new

What I built A small business owner needed an automated customer support system that works 24/7, answering questions based only on their internal policies – no hallucinations, no outside internet knowledge. They also wanted multilingual support (English, French, Spanish) and a natural AI voice introduction. I built the AI Customer Service Suite to solve this exactly. Key features Answers questions strictly from uploaded documents (PDF, DOCX, TXT) – no generic AI guessing Multilingual chat interface (English, French, Spanish) Female AI voice introduction that explains the software and pricing Security badge and Stripe payment link for licensing Optional Twilio integration for WhatsApp and voice calls Full source code delivered Tech stack Python Streamlit Groq Llama 3.1 (RAG) edge‑tts for voice Twilio API (optional) Live demo https://ai-customer-service-suite-bemey6yywchvkz7yrghufc.streamlit.app/ What we do at GlobalInternet.py We provide tailored software solutions that connect the global market with local expertise. We build custom AI‑powered applications, business tools, and automation systems – delivered fast with full source code. Contact us Phone: (509) 4738 5663 Email: deslandes78@gmail.com Website: https://globalinternetsitepy-abh7v6tnmskxxnuplrdcgk.streamlit.app/ What's next I am adding more language options and a live dashboard for businesses to track support questions and user satisfaction. Feedback welcome Try the live demo, break it, ask it questions. I would love to hear your suggestions or feature requests. Comment below or reach out via my website. #python, #streamlit, #chatbot, #ai, #customercare

AI Agent Security, Open-Source Code Generation, and Frontier Models on Bedrock Today's Highlights This week highlights a new security scanner for AI agent skills, the open-source release of Xiaomi's MiMo Code model, and the general availability of OpenAI's GPT-5.5 and Codex on Amazon Bedrock. These advancements empower developers with practical tools and platforms for building, securing, and deploying applied AI solutions. SkillSpector — Vendor-Backed Security Scanner for AI Agent Skills (Dev.to Top) Source: https://dev.to/alya_mahalini_f05d9953cfa/skillspector-vendor-backed-security-scanner-for-ai-agent-skills-well-scoped-but-dependent-on-4530 SkillSpector is introduced as a security scanner designed to analyze AI agent skills before their deployment. These skills, often packaged as code or configuration bundles, are utilized by large language models like Claude, Codex, and Gemini to extend their capabilities and interact with external systems. The scanner's primary function is to detect potential vulnerabilities within these bundles, aiming to prevent security exploits in production AI agent systems. It focuses on well-scoped issues but relies on static patterns for detection, suggesting a rule-based approach to identifying common pitfalls in agent skill development. The tool addresses a critical emerging need in the AI lifecycle: securing the extensible components of AI agents. As AI agents gain more autonomy and access to external tools, the integrity and security of their "skills" become paramount. SkillSpector offers a way for developers and security teams to vet these components, helping to build more robust and trustworthy AI applications. While the article notes its dependency on static patterns, implying potential limitations for novel attack vectors, it represents a concrete step towards formalizing security practices for AI agent orchestration and deployment, moving beyond just the LLM itself to the code it executes. Comment: This is a crucial tool for a

In the previous post , we talked about context windows. The model has a fixed-size desk and everything has to fit on it at once. When too much is on the desk, things in the middle get missed. I ended that post with a promise: what if there was a way to give the model just the right piece, at the right time, from a document you've never even pasted in? That's this post. We're giving the model a search system. The problem: your document is too long You have a 2000-page document. An employee handbook, a product manual, internal documentation. You need one specific answer from it. You can't paste the whole thing into the model's context window. And even if you found a model with a window big enough, we learned what happens: attention degrades, things in the middle get missed, and the model answers confidently from the wrong section. So you need something different. A step that happens before the model sees anything. Something that finds the 2-3 paragraphs that actually answer your question, and passes only those to the model. That's retrieval. The full technique is called RAG: Retrieval-Augmented Generation . Search first, then generate. Three words, one loop Let's break the name down. Each word is a step. Retrieval. Go find relevant information. Think of it like checking the index of a textbook before diving into a chapter. You don't re-read the whole book. You find the right page first. Augmented. Add that retrieved info to the prompt. You're supplementing the model's built-in knowledge with fresh, specific context. Like handing someone a cheat sheet right before they answer a question. Generation. The model writes its response, but with the retrieved context sitting right there in the conversation. It generates an answer grounded in your actual data, not just its training. "Grounded" means the model has real evidence to point to. It's not guessing from memory. It's answering from something you gave it. The whole loop in one sentence: find the right chunks of informat

Ask a large language model for a specific statistic, then ask where it found that number. More often than not, the citation it gives you doesn't exist. The model will hallucinate a plausible-looking reference, confidently present outdated conclusions, or simply make things up without any internal signal that something is wrong. This failure mode has a well-known name — hallucination — and the most widely adopted engineering solution for it is RAG. RAG in One Sentence RAG stands for Retrieval-Augmented Generation. The idea is straightforward: before the LLM generates an answer, retrieve relevant document chunks from an external knowledge base, then feed those chunks to the model as context so it can compose its response based on real source material rather than parametric memory alone. Think of it like writing a research paper. You don't cite statistics from memory; you look them up first, then write your argument around verified data. RAG gives language models the same "look it up, then write" workflow. Three Structural Limitations of LLMs To understand why RAG is necessary, we need to identify the specific gaps it fills. Knowledge cutoff. Every model has a training data deadline. GPT-4's cutoff is late 2023; Claude's is early 2025. Anything that happened after that deadline simply doesn't exist in the model's world. It will either admit ignorance or, more dangerously, fabricate an answer that sounds current. Bounded parametric capacity. Even a 100-billion-parameter model can only "memorize" so much. Long-tail facts, niche domain knowledge, your company's internal documentation, yesterday's meeting notes — none of these are in the weights. No built-in fact-checking. Token generation is probabilistic sampling. The model has no mechanism to distinguish whether it's recalling a training fact or pattern-matching its way into a plausible-sounding fiction. RAG addresses all three: it supplies up-to-date, verifiable, externally sourced evidence at inference time. How RAG W

After debugging 20+ broken RAG systems, I've identified the 6 decisions that determine whether yours works. Here's how to get each one right. The RAG Developer's Trap Every RAG developer falls into the same trap: you build the basic pipeline, it sort of works, and then you spend weeks tweaking prompt templates — while the real problem sits untouched in your indexing pipeline. The 80/20 rule: 80% of RAG problems come from indexing, not generation. But 80% of debugging effort goes into generation. Let's fix that. Decision 1: Embedding Model — The Single Biggest Lever The mistake: Using all-MiniLM-L6-v2 for Chinese documents because it's the default in every tutorial. Why it's wrong: It's English-trained. Drop it on Chinese text and it loses 30-50% of semantic fidelity. Language Use This Chinese BAAI/bge-large-zh-v1.5 (1024-dim) Chinese + English BAAI/bge-m3 (multilingual + sparse) English text-embedding-3-large Code jina-embeddings-v3 or voyage-code-3 Non-negotiable: Indexing model and query model must be byte-for-byte identical. Switch models = rebuild entire index. Impact: +15-40% Recall@10 for Chinese RAG. Decision 2: Chunk Size — Not a Magic Number Physics: Too small (< 100 tokens) = semantic fragmentation. Too large (> 1000 tokens) = noise injection. Document Type Sweet Spot Overlap FAQ / Short-form 128-256 20 Technical docs 512 50 Long-form articles 768-1024 100 Code Function boundaries 0 The method matters more than the size. Use recursive splitting, not fixed-length: from langchain.text_splitter import RecursiveCharacterTextSplitter splitter = RecursiveCharacterTextSplitter ( chunk_size = 512 , chunk_overlap = 50 , separators = [ " \n\n " , " \n " , " . " , " " , "" ] ) Impact: +5-15% Recall@10. Decision 3: Index Type — HNSW vs IVF Scale Use Why < 1M vectors HNSW Recall > 0.95 1-5M, RAM tight IVF + PQ 75% memory savings > 5M IVF + PQ + Sharding Horizontal scale Key nuance: HNSW has high insertion cost. Streaming docs → IVF may be better even at small scale. Im

There is a design assumption baked into almost every vector database and AI memory implementation that sounds reasonable until you watch it grow nodes in production: that remembering more is always better. Through testing and refining our AUDN code, that is not exactly correct. After running VEKTOR Slipstream against real development sessions for 99 days, the database held 1,413 stored memories across four namespaces. Looking at the importance score distribution, 83 percent of those memories sat below 0.25 out of 1.0, what the system considers the noise floor. The remaining 17 percent, just 60 memories out of 1,413, sat above 0.75 and dominated every recall result. This is exactly what a curation layer is supposed to produce. Those 1,154 low-scored memories are accurate. They are not deleted. They are retrievable by direct query. What they are not is important enough to compete with the 60 high-signal entries every time the agent needs context. AUDN penalised them gradually over hundreds of writes because similar, more specific, or more frequently reinforced memories covered the same ground better. The system created a hierarchy. Without curation, all 1,413 memories would compete equally for every recall slot — and the agent would consistently surface redundant, lower-value context alongside the things that actually matter. That is what standard vector memory looks like without a curation layer. A slow, invisible degradation that nobody notices until the agent starts confidently giving you answers that are three months out of date. Every memory node in Vektor carries an importance score between 0 & 1. When a memory is first stored, it receives a score based on the content’s estimated significance. That score is not fixed. Every time a new memory arrives that is semantically related but not directly contradictory, the compatible verdict for that existing memory takes a small redundancy penalty. The penalty is intentionally modest: a factor based on how similar the in

Electricity demand from AI data centers is pushing everyone — including automakers like GM and Ford — into the energy storage business.

Electricity demand from AI data centers is pushing everyone — including automakers like GM and Ford — into the energy storage business.

Ambrosia Energy wants to build power plants in less than 12 months while undercutting natural gas. It hopes to build gigawatts worth by 2030.

GM is developing an entirely new sodium-ion battery chemistry for use in everything from data centers to its own factories.

This project presents an offline voice agent that uses Indonesian law data from the Pasal ID API and is optimized for the Indonesian language. It is capable of understanding spoken Indonesian, generating responses in Indonesian, and speaking back in Indonesian without requiring cloud APIs. The system combines Whisper-based speech recognition, Ollama-hosted LLMs, and local text-to-speech models to provide a privacy-preserving conversational AI experience. You can access the project repository here: PasalVA . Usually, when using voice assistant applications, we need to rely on cloud-based services, which creates dependence on third-party providers. An internet connection becomes mandatory, which impacts usability in environments with limited or unreliable network access. In addition, cloud-based solutions require operational costs because requests must be sent to third-party servers. To address these challenges, this project aims to develop a fully local voice agent that is capable of functioning as a voice assistant by eliminating external service dependencies while supporting the Indonesian language. System Architecture The application flow follows a voice assistant architecture with additional Retrieval-Augmented Generation (RAG) capabilities to retrieve relevant Indonesian laws. User │ ├── Text Query │ │ │ ▼ │ Text Input │ └── Voice Query │ ▼ Microphone │ ▼ Speech-to-Text │ ▼ Text Processing │ ▼ Retrieve Related Laws │ ▼ LLM (Ollama) │ ▼ Response Text │ ├── Display in UI │ ▼ Text-to-Speech │ ▼ Speaker Output The application allows users to either type their query or use a microphone to ask a question. For voice input, the audio is first converted into text using a Speech-to-Text (STT) model. The resulting text, along with directly typed queries, is then processed to remove noise and normalize the input. After preprocessing, the query is converted into embeddings and used to retrieve relevant Indonesian laws from the local knowledge base. The retrieved legal contex