RAG

34 posts

aws3 min readCurated summary

Amazon DynamoDB now supports real-time vector search at any scale | Amazon Web Services

Amazon DynamoDB now offers native vector search, allowing applications to store embeddings beside operational data and query them without a separate vector database. The serverless service provides single-digit millisecond latency, 99%+ recall, horizontal scaling, and support for trillions of vectors. This removes synchronization pipelines, data movement, and additional infrastructure for applications already built on DynamoDB. ## Native Vector Search in DynamoDB - Embeddings are stored directly in DynamoDB as lists of floating-point numbers. - Similarity searches use the `SearchVectors` API and return up to 100 ranked results. - Vector indexes scale horizontally without storage limits or servers to manage. - Pricing follows DynamoDB’s pay-per-request model. - Common use cases include: - Agent memory - Retrieval-augmented generation - Recommendations - Personalized experiences - Anomaly detection ## Supported Search Capabilities - Supports vectors with up to 4,096 dimensions. - Offers three distance functions: - **Cosine**: Useful for semantic text similarity. - **Euclidean**: Useful when vector magnitude is meaningful. - **Dot product**: Useful when both direction and magnitude affect relevance. - Supports optional partition keys to distribute data and scope searches. - Supports inline exact-match filters, but not range operators such as `BETWEEN` or `BEGINS_WITH`. - Search results can include operational attributes through index projections. ## Adding Embeddings to an Existing Table - Generate embeddings with a model such as Amazon Bedrock Titan Text Embeddings, Cohere Embed, or OpenAI embeddings. - Store them in a new attribute, such as `descriptionEmbedding`, using `UpdateItem` or other AWS tooling. - No new DynamoDB data type or schema migration is required because vectors use the existing `List` and `Number` types. ## Creating and Using a Vector Index - Create a vector index on the embedding attribute. - Configure: - Index name - Vector attribute - Embedding dimensions - Distance function - Optional partition key - Filter attributes - Generate a query embedding with the same model used for stored data. - Call `SearchVectors` with the query vector, result count, partition key, and filters. - Scores depend on the distance function: - Lower scores indicate greater similarity for Cosine and Euclidean distance. - Higher scores indicate greater similarity for Dot product. ## Example: Product Catalog Search - A `ProductCatalog` table stores product details such as `productId`, `name`, `description`, `category`, `marketplace`, and `price`. - Product descriptions receive embeddings stored in `descriptionEmbedding`. - A `ProductDescriptionIndex` can use: - `marketplace` as the partition key - `category` as an inline filter - Cosine distance for semantic matching - A query such as “lightweight running shoes for summer” can return the five most relevant footwear products in the US marketplace, along with attributes such as name and price. DynamoDB vector search is best suited to applications whose operational data already resides in DynamoDB and need semantic retrieval without operating a second database or synchronization system.

Read original(opens in new tab)
figma2 min readCurated summary

How We Secure Figma’s Internal Systems With Agents | Figma Blog

Figma built an AI-powered security agent to reduce the manual work involved in investigating SIEM alerts. What began as a retrieval system for finding similar past incidents evolved into an agent that investigates alerts, queries security data, writes fixes, opens pull requests, and retains useful knowledge. The system reportedly reduced alert time-to-resolution by 71% and changed how security engineers handle on-call work. ## The Challenge of Internal Security Operations - Figma’s infrastructure, SaaS tools, identity systems, and employee devices change constantly. - Panther, Figma’s SIEM, monitors these systems and sends alerts to Slack while creating Asana tickets. - On-call engineers previously spent significant time gathering context: - Comparing alerts with incidents from the previous week - Checking whether an existing pull request addressed the issue - Searching Slack discussions for related investigations - Determining whether an alert was new, recurring, or already understood - Existing agent work focused on securing Figma’s codebase, but the team needed a broader system for the many issues detected by its SIEM. ## The RAG Layer: Giving Alerts Historical Context - Figma first created a retrieval-augmented generation system using: - AWS Bedrock Knowledge Bases - Amazon Kendra - Lambda handlers connected to Panther - Each Panther alert is converted into a standardized searchable document. - The system extracts structured information such as: - IP addresses - Usernames and actors - AWS account IDs from ARNs - Alert type, severity, tags, status, and timestamps - Similar alerts are retrieved semantically using the alert title, typically containing the detection name and actor username. - Searches prioritize: - Recent alerts, since investigation procedures evolve - Alerts containing actual investigation context - Comments from engineers rather than merely closed alerts ## Turning Engineer Comments into Institutional Memory - When an on-call engineer comments in a Slack alert thread, Figma captures that text and attaches it to the original alert. - Asana tickets follow a similar process. - The updated alert document is reindexed with: - The accumulated investigation comments - A `has_investigation_context` flag - Future alerts can retrieve these previous explanations and recommendations. - Engineers do not need to adopt a separate annotation workflow; their normal Slack and Asana comments become reusable knowledge. - Each useful investigation effectively makes subsequent similar alerts faster and less expensive to triage. Figma’s approach demonstrates how security agents can build on existing workflows rather than requiring entirely new ones. Starting with searchable historical context allowed the team to progressively develop a broader agentic system while turning everyday investigative work into persistent operational knowledge.

Read original(opens in new tab)
cloudflare2 min readCurated summary

Unmasking the crawls with Attribution Business Insights

Cloudflare argues that the traditional exchange between crawlers and publishers has broken down as AI bots extract content without sending meaningful referral traffic. This creates lost revenue for publishers while increasing hosting costs, making granular traffic attribution essential. Its new Attribution Business Insights dashboard aims to help site owners identify which bots provide value and make informed decisions about access, blocking, and commercial relationships. ## The Internet’s Changing Economics - Traditional search engines generally crawled content a few times for each visitor they referred. - That crawl-to-referral balance supported advertising, affiliate revenue, subscriptions, and direct audience relationships. - AI crawlers increasingly create a “zero-click” ecosystem by summarizing content without directing users to the original publisher. - Cloudflare observed AI crawl-to-referral ratios ranging from 118:1 to nearly 50,000:1. - Publishers face both reduced traffic-based revenue and higher infrastructure costs from unproductive automated access. ## Attribution Business Insights Dashboard - The dashboard is available to Cloudflare Bot Management customers. - It provides an immediate view of bot activity without requiring extensive manual analytics filtering. - It measures: - Human versus bot traffic to content pages. - Overall and operator-specific crawl-to-referral ratios. - Crawl-to-referral trends over 24 hours, seven days, or 30 days. - Top bots by traffic volume, country, bandwidth usage, and current allow/block status. - AI crawlers are classified by behavior: - **Training:** collecting data for future large language models. - **Search:** refreshing indexes used by retrieval-augmented generation. - **Agent:** supporting automated interactions that return answers to users. ## Turning Traffic Data into Business Strategy - Site owners can use high-level metrics to evaluate whether their content security policies are effective. - More detailed operator-level data helps publishers understand how individual AI companies use their content. - Comparing operators can support negotiations about: - Blocking or allowing specific crawlers. - Licensing content. - Reconsidering existing commercial agreements. - Prioritizing relationships with companies that provide meaningful compensation or referrals. - The dashboard is intended to give publishers concrete evidence—such as comparative crawl volumes and referral performance—when discussing content access with AI companies. Cloudflare’s recommendation is effectively to stop treating all crawlers alike. Publishers should use crawl-to-referral ratios, resource consumption, crawler purpose, and commercial value to decide which bots deserve access and under what conditions.

Read original(opens in new tab)
aws3 min readCurated summary

Top announcements of the AWS Summit in New York, 2026 | Amazon Web Services

AWS Summit New York 2026 focused on making AI agents more capable, secure, autonomous, and easier to operate in production. Announcements spanned Amazon Bedrock AgentCore, security automation, developer tooling, workplace agents, and S3 data management. The overall direction is toward agents that can access governed knowledge, act independently, and continuously improve while remaining subject to enterprise controls. ## Building More Capable Agents - **Amazon Bedrock Managed Knowledge Base** simplifies enterprise RAG with native data connectors, Smart Parsing for multi-format data, and an Agentic Retriever for complex, multi-step queries. - **Web Search for Bedrock AgentCore** provides managed, current, cited web knowledge while keeping data within the customer’s secured AWS environment. - **Bedrock AgentCore harness** is now generally available, allowing developers to define an agent’s model, tools, skills, and instructions through configuration rather than custom orchestration loops. - **AWS Context**, coming soon, will map relationships across organizational data into a knowledge graph. Agents will be able to use governed relationships, business rules, and domain knowledge at runtime. - **AWS WAF Bot Control** lets publishers and content owners price, meter, and collect payment from AI bots accessing content and APIs, with scoped access enforced at the edge. ## Securing Agents and Applications - **AWS Continuum**, available in gated preview, aggregates vulnerability findings, ranks them by business impact, verifies exploitability, and routes fixes through existing development processes. - **AWS Security Agent**, now part of Continuum, adds: - Threat modeling based on the STRIDE framework - Pull-request code scanning and remediation across major Git platforms - IDE integrations through Kiro, Claude Code, and MCP - These tools are intended to let developers perform security reviews and address vulnerabilities without leaving their normal workflows. ## AI-Assisted Software Development - **Kiro for iOS**, in gated preview, lets developers start, monitor, steer, and approve Kiro sessions from a phone, including reviewing diffs and approving changes without keeping a laptop running. - **AWS DevOps Agent** adds release readiness reviews and autonomous release testing. It evaluates changes against natural-language standards and tests them in production-like environments. - **AWS Transform continuous modernization**, in preview, scans repositories against configurable technical-debt baselines and can autonomously generate remediation pull requests. ## Autonomous Workplace Agents - New **Amazon Quick autonomous agents** can work in the background with defined expertise, tone, permissions, and tools. - Example use cases include: - A finance agent processing incoming orders - A sales agent analyzing CRM, email, and Slack activity - Agents drafting follow-ups, identifying risks, and recommending next steps - A new **activity feed** combines email, messaging, calendars, and tasks into a prioritized view that adapts to the user’s communication and work patterns. ## Richer Metadata for Amazon S3 - **S3 annotations** allow up to 1 GB of mutable, queryable context to be attached directly to an object. - The feature targets AI agents and autonomous workflows that need to discover and interpret data without maintaining separate metadata systems. AWS’s announcements point toward an agent ecosystem that combines managed knowledge retrieval, web access, security automation, autonomous development workflows, and persistent workplace assistance. Organizations adopting these capabilities should pair autonomy with strong governance, scoped permissions, and continuous validation in production.

Read original(opens in new tab)
aws3 min readCurated summary

Introducing Amazon Bedrock Managed Knowledge Base for faster, more accurate enterprise AI applications | Amazon Web Services

Amazon Bedrock Managed Knowledge Base is a managed service for building enterprise generative AI applications over proprietary data. It abstracts storage, retrieval, embeddings, reranking, and model selection while adding native connectors, automated parsing, and agentic retrieval. The result is a faster way to create scalable, accurate RAG-based agents without maintaining the underlying infrastructure. ## Enterprise Knowledge Base Challenges - Enterprise data is distributed across systems with different formats, permissions, and access controls. - RAG accuracy requires ongoing experimentation with parsing, chunking, embedding models, and retrieval behavior. - Organizations must support either massive knowledge bases containing millions of documents or thousands of smaller ones while controlling cost and enforcing security. - These infrastructure tasks divert developers from building application functionality. ## Managed RAG Infrastructure - Managed Knowledge Base combines storage, retrieval, embeddings, reranking, and foundation model selection into one managed primitive. - The service automatically selects and manages default embedding, reranking, and foundation models. - It can scale end-to-end RAG pipelines with only a few lines of code. - Through Amazon Bedrock AgentCore Gateway, it is available as a pre-built target with automatically generated role-based permissions, observability, and evaluation metrics. ## Native Data Connectors - Six built-in connectors ingest enterprise content and permissions directly from: - Amazon S3 - SharePoint - Confluence - Web Crawler - Google Drive - OneDrive - Connectors eliminate the need to build and maintain application-specific ingestion logic. - IAM roles are created automatically, with the option to customize permissions. ## Smart Parsing Smart Parsing automatically chooses ingestion and parsing techniques based on the source and content type. - Connector-specific models preserve important structure: - Web Crawler retains HTML structure, embedded images, and tables. - SharePoint preserves document hierarchies and relationships. - Multimodal processing detects document content types, identifies bounding boxes, and uses foundation models for extraction and captions. - Optimized chunking uses document structure and content type to balance retrieval quality and performance. - Developers can rely on defaults or customize chunking strategies for advanced use cases. ## Agentic Retriever Agentic Retriever is designed for complex questions requiring multi-step reasoning and retrieval. - It decomposes a query into a sequence of subquestions. - It performs multihop retrieval within one knowledge base or across multiple knowledge bases. - It evaluates intermediate results and stops once sufficient relevant passages have been found. - For example, it can connect a team’s cloud budget with an expense policy governing annual prepayments—something a single retrieval step might miss. - Retrieved context can then support more accurate, grounded responses from enterprise agents. ## Getting Started - Create a Managed Knowledge Base from the Amazon Bedrock AgentCore or Amazon Bedrock console. - Choose **Create Managed KB** and select **Unstructured Vector Store KB**. - Select a supported data connector and accept the optimized defaults. - After synchronization, connect the knowledge base to an agent or expose it as a tool for a foundation model. Managed Knowledge Base is best suited to teams that want production-ready enterprise RAG without assembling and operating every component themselves, while retaining customization options for specialized accuracy or governance requirements.

Read original(opens in new tab)
line4 min readCurated summary

Transitioning from a Legacy Project to an AI-Driven Project: The AX Roadmap

AI transformation (AX) is not achieved by simply adding AI tools; it requires redesigning the team’s development system around AI. The post proposes a four-stage roadmap for turning legacy projects into AI-driven projects, beginning with security and standardization and progressing toward specification-based development automation. Its central recommendation is to introduce AI gradually, with clear documentation, human approval gates, and measurable outcomes. ## What an AI-Driven Project Means - AI participates throughout the development lifecycle, including: - Specification writing - Code generation - Testing - Code review - Pull request creation and merging - Developers focus more on direction, judgment, and business decisions rather than repetitive implementation work. - The key methodology is **spec-driven development (SDD)**: - Requirements and implementation specifications are defined before code. - AI generates, tests, and reviews code against those specifications. - Structured specifications compensate for AI’s difficulty in interpreting ambiguous intent. ## Stage 1: AI-Ready — Establish Security and Compliance The first stage creates a safe foundation for using AI with project context and company data. - Remove hardcoded secrets such as API keys, database passwords, and internal IP addresses. - Use secret-management services to inject credentials dynamically at runtime. - Protect personally identifiable information by masking or tokenizing names, emails, phone numbers, and similar data before sending it to AI systems. - Separate or restrict access to critical intellectual property, including proprietary algorithms and sensitive architecture. - Define minimum compliance requirements first rather than delaying adoption until every security improvement is complete. - Use sandboxing, system prompts, filesystem restrictions, and network isolation to limit AI access. - Validate that isolation mechanisms actually prevent sensitive-data exposure. Expected benefits include safer AI usage, faster debugging and repetitive coding, and accumulated team experience that supports later adoption stages. ## Stage 2: AI-Assist — Standardize Team Usage This stage addresses teams where individuals already use AI but follow inconsistent practices. - Create project-level AI guidelines covering: - Project context - Coding conventions - Architecture principles - Domain terminology - Establish shared prompts, skills, or plugins for activities such as: - Brainstorming - Writing implementation plans - Code review - Subagent-driven development - Integrate AI into CI/CD for automated first-pass code reviews. - Let AI identify style violations, likely bugs, and security issues. - Reserve human review for complex business logic, architecture, and policy decisions. - At this stage, AI assists with human-written code rather than independently implementing features. Possible KPIs include: - A reduction in repetitive human review comments. - Increased test coverage. - Improved deployment reliability and system stability. - More consistent adherence to team conventions. ## Stage 3: AI-Development — Automate Implementation The third stage connects specifications directly to working code through an automated pipeline. - The pipeline includes three human approval gates: 1. **Specification review:** Confirm requirements, scope, edge cases, and validation criteria. 2. **Implementation and test-plan review:** Approve the AI-generated execution and testing plans. 3. **Code review:** Approve the final implementation before merging. - AI uses documented domain knowledge and architecture context to generate project-specific code. - A new file in a directory such as `/specs` can trigger CI automation. - CI can generate an implementation plan, execute coding tasks through independent subagents, run tests, and create a pull request. - Approval steps ensure that AI cannot proceed to the next stage without human authorization. To improve adoption, the post recommends expanding AI’s responsibilities gradually: - Begin with unit- and integration-test generation for existing logic. - Move progressively toward boilerplate and broader implementation work. - Avoid delegating critical business logic immediately, since poor early results can undermine team trust. ## Overall Adoption Principles - Each roadmap stage provides value independently; teams do not need to complete all four stages at once. - The appropriate target depends on team maturity, risk tolerance, domain complexity, and adoption speed. - Documentation is essential because AI needs structured project and business context. - Human oversight remains important, especially for requirements, architecture, business rules, and final code approval. - Security controls, common workflows, and measurable KPIs should develop alongside AI usage. Teams should start with the safest achievable stage, standardize practices before automating implementation, and expand AI’s role only as documentation, testing, and review processes become reliable.

Read original(opens in new tab)
kakao3 min readCurated summary

Key Players in the Agentic AI Ecosystem: MCP Player 10 Wraps Up, and What’s Next!

Kakao’s first MCP Player 10 competition showcased how developers are using Model Context Protocol (MCP) to build practical agentic AI services. More than 150 teams participated, and ten finalists were selected for solutions addressing childcare, startup support, culture, gaming, legal research, and safety. Kakao plans to expand this ecosystem through the upcoming Agentic Player 10 competition and deeper integration with Kakao Tools. ## The MCP Player 10 Competition - The competition ran from December 19, 2025, to January 18, 2026, on Kakao’s PlayMCP open platform. - It emphasized: - Creativity - Everyday usefulness - Technical stability - The goal was to encourage developers to create MCP servers that solve real-world problems with AI. - Ten teams were selected after internal evaluation and received a share of 21 million won in support funding, along with opportunities to collaborate with Kakao. ## Award-Winning MCP Services ### 어린이ZIP: AI Assistant for Childcare Teachers - Automates administrative work for daycare and kindergarten teachers. - Analyzes uploaded activity photos to generate drafts of parent notices and childcare journals. - Remembers child-specific details such as allergies and pickup arrangements. - Produces personalized responses in a warm, professional tone. ### SeedUp: Startup Support-Program Research - Collects and analyzes fragmented government startup-support announcements. - Summarizes eligibility requirements and relevant opportunities. - Helps founders develop application strategies. - Supports natural-language requests such as finding weekly deadlines or analyzing an uploaded announcement. ### Other Selected Services - **공유 비밀의 방:** An anonymous platform for sharing and empathizing with personal stories and AI conversations. - **바우만 16 안티에이징솔루션:** Recommends skincare routines using the Baumann 16 skin-type classification, cosmetic ingredient data, and skin pH analysis. - **아라드도우미:** A Dungeon & Fighter assistant using RAG and Vision AI to analyze patch notes, item trends, and optimized character builds. - **키즈허브:** Aggregates public data such as emergency-room availability, childcare waiting lists, and child-development information. - **택배추적기:** Combines package tracking with AI-based detection of smishing URLs in delivery-related messages. - **ArtBridge:** Recommends performances and exhibitions from approximately 200,000 records across nine cultural categories, using location, budget, and preferences. - **KidSafe:** Detects harmful language and emotional-crisis signals in children’s chatbot conversations, escalating serious cases to guardians or professional resources. - **LexiLink_ko:** Searches and organizes statutes, court precedents, and administrative interpretations through natural-language queries. All ten MCP servers are now officially available through the PlayMCP platform. ## PlayMCP’s Future Direction - PlayMCP will remain a developer-focused environment for building and distributing MCP servers. - Kakao Tools, available through ChatGPT for Kakao, will focus on helping general users experience MCP-based services. - Kakao plans to connect the two platforms more closely. - Kakao is considering managed infrastructure, including: - Kakao Cloud-based server support - Automated deployment - Greater operational responsibility for MCP service stability - PlayMCP may also support richer in-app interfaces through JSON-based widgets, similar to those already available in ChatGPT for Kakao. ## The Next Competition: Agentic Player 10 Kakao announced a second competition, Agentic Player 10, designed to connect developer-created agents with Kakao Tools and expose them to a broader audience. The program is positioned as an opportunity for startups and aspiring founders to test their services with real users and potentially bring their agents into KakaoTalk. Developers interested in building practical AI agents are encouraged to use PlayMCP and participate in Agentic Player 10 as the next step in Kakao’s expanding agentic AI ecosystem.

Read original(opens in new tab)
google3 min readCurated summary

Unlocking dependable responses with Gemini Enterprise Agent Platform’s Agentic RAG

Google’s Agentic RAG framework extends traditional retrieval-augmented generation to handle complex, multi-source enterprise questions. Its multi-agent system plans searches, rewrites queries, routes them across data sources, and iteratively retrieves missing information instead of stopping after one pass. A Sufficient Context Agent verifies that the evidence supports every part of the request, improving factual accuracy by up to 34% on evaluated datasets. ## Why Standard RAG Falls Short - Conventional RAG typically performs one retrieval step before generating an answer. - Enterprise information is often distributed across separate data sources and requires multi-hop reasoning. - For example, a project document may contain a server ID, while the server’s specifications exist in another database. - Without a second search, the system may produce an incomplete answer or incorrectly conclude that the information is unavailable. ## Multi-Agent Planning, Rewriting, and Routing The framework divides research into specialized roles: - **Orchestrator:** Determines whether the request requires multiple steps and delegates tasks. - **Planner Agent:** Maps the information needed and identifies which sources to search. - **Query Rewriter:** Converts a broad question into targeted search queries. - **Search Fanout Agent:** Sends those queries to multiple retrieval systems. - **Synthesis Agent:** Combines the gathered evidence into the final response. This architecture is designed to coordinate complex searches rather than treat retrieval as a single matching operation. ## Iterative Retrieval with Sufficient Context The central innovation is persistence: the system detects when its evidence is incomplete and continues searching. - The **Sufficient Context Agent** reviews: - Retrieved text snippets - An intermediate draft answer - The original user request - It identifies which requested elements are supported and which are missing. - Instead of merely reporting insufficient information, it produces specific feedback describing the gap and suggesting what to search for next. - This feedback drives another query-rewriting and retrieval cycle. - Retrieval stops only when the system determines that the available context is sufficient for a grounded answer. ## Example: Patient Discharge Information For a request involving medications, dietary restrictions, and allergic reactions, the workflow proceeds as follows: - The Root Agent delegates the task to Pharmacy, Nutrition, and Clinical Notes sub-agents. - The initial search finds medication and diet information but no obvious allergy records. - The Sufficient Context Agent flags the missing allergy information. - The Query Rewriter generates focused searches such as “rashes” or “adverse events.” - A deeper search finds the missing evidence. - The system performs a final context check before producing the doctor’s summary. ## Evaluation Results - The framework was evaluated on the FramesQA benchmark, which contains multi-hop questions. - It reportedly improved factuality accuracy by up to 34% compared with standard approaches. - Google also tested it on proprietary internal datasets and observed better grounding and reasoning accuracy across several domain-specific tasks. - The approach is hosted through Gemini Enterprise Agent Platform’s Cross-Corpus Retrieval capability. Agentic RAG is most useful when answers depend on several documents, databases, or reasoning steps. For enterprise deployments, iterative retrieval and explicit context verification can reduce incomplete answers and unsupported guesses, though they add orchestration and retrieval overhead.

Read original(opens in new tab)
line3 min readCurated summary

ODW #5: Building a RAG System with a Vector DB and Agent Skills

The workshop demonstrated how a lightweight RAG system can make large collections of technical documentation easier for developers and AI agents to use. Using ChromaDB, Swift Evolution proposals were indexed locally and exposed to Claude Code through MCP. Agent skills then simplified searches by teaching the agent which collection, metadata, and query practices to use. The approach improves document discovery and can support code generation and review. ## Why RAG Is Needed - Large application teams maintain extensive documentation and architectural guidelines. - Developers often spend significant time searching for information about: - Introducing dependencies - Resolving build errors - Following architectural rules - Asking experts can solve problems, but consumes time for both the questioner and the responder. - RAG provides AI agents with structured, searchable knowledge so they can answer questions more accurately using internal documents. ## Building a RAG System with ChromaDB - The workshop used ChromaDB, an open-source local vector database with Python and JavaScript client libraries. - Swift Evolution proposals served as the sample dataset: - Approximately 500 Markdown documents - Consistent structure and proposal IDs such as `SE-0400` - Metadata including implementation status and authors - Participants indexed the documents locally and connected the database to Claude Code through an MCP tool. - This allowed the coding agent to retrieve and reference Swift language proposals during conversations. ## Improving Search with Agent Skills - MCP exposes the available database tools, but the agent still needs to know: - Which collection contains the relevant data - Which metadata fields are useful - How to formulate effective queries - A dedicated `searching-swift-evolution` skill encoded this knowledge, including: - The `swift-evolution` collection name - Proposal ID formats such as `SE-0255` and `ST-0001` - Metadata such as `Status` and `Authors` - A recommendation to query in English - With the skill, users could issue simple requests such as “Investigate SE-0500” without explaining the database structure or MCP workflow. - The workshop also covered skill mechanics, authoring best practices, and practical skill development. - Participants later indexed their own Markdown documents, created search skills, and learned how to deploy the database to LY Corporation’s internal Flava cloud for sharing. ## Potential Applications - Natural-language document search can make internal technical knowledge significantly more accessible. - Coding agents can retrieve relevant documentation automatically before: - Generating code - Reviewing code - Checking compliance with architectural or implementation guidelines - Combining RAG with agent skills or Claude Code sub-agents can embed organizational knowledge directly into development workflows. ## Workshop Design and Results - The online workshop used demonstrations by instructors and mock participants. - More than 1,000 people attended. - Its structure balanced lectures and hands-on exercises: - Lectures explained the core concepts concisely. - Practical demonstrations showed how to apply the system to real work documents. - This balance helped participants understand both the underlying ideas and their practical use. Overall, the workshop showed that a local vector database plus MCP and well-designed agent skills can provide a simple, effective foundation for searchable engineering knowledge and AI-assisted development.

Read original(opens in new tab)
cloudflare3 min readCurated summary

Why we-re rethinking cache for the AI era

AI traffic is fundamentally changing how CDNs should think about caching. Unlike human visitors, AI crawlers make broad, high-volume, often sequential requests for long-tail content, creating low reuse and substantial cache churn. Cloudflare argues that traditional LRU-based caching and techniques such as prefetching are increasingly poorly suited to this traffic, forcing operators to rethink cache design if they want to support AI access without harming human performance. ## Why AI Traffic Is Different - Automated traffic accounts for 32% of Cloudflare’s network traffic, including crawlers, scrapers, and AI assistants. - AI agents often: - Send many requests in parallel. - Scan large portions of a website sequentially. - Request rarely visited or loosely related pages. - Fetch documentation, images, and articles from many sources. - AI crawlers represent approximately 80% of self-identified AI bot traffic. - Most single-purpose AI bot traffic is associated with model training, with search-related crawling a distant second. ## The Three Defining Characteristics of AI Crawlers - **High unique URL ratio:** More than 90% of pages observed in large-scale Common Crawl datasets are unique by content. - **Content diversity:** Different crawlers target different materials, including source code, technical documentation, media, and blog posts. - **Crawling inefficiency:** Many requests lead to 404 errors or redirects because of poor URL handling. - AI crawlers generally lack browser-side caching and shared session behavior, so independent crawler instances may repeatedly appear as new visitors. - They can also repeatedly revisit content while iteratively refining search results, but each iteration still tends to fetch mostly new pages. ## How AI Crawling Disrupts Traditional Caches - Conventional CDN caching keeps frequently requested content available near users and evicts less recently used objects when storage fills. - Cloudflare uses an LRU (least recently used) policy, but broad AI scans introduce large numbers of low-reuse objects. - These objects can evict content that human visitors are more likely to request. - AI-driven long-tail access increases cache misses and sends more requests back to origin servers. - Cache speculation and prefetching become less effective because crawler access patterns are difficult to predict. - Higher miss rates can cause: - Slower responses. - Increased origin-server load. - Greater egress costs. - Reduced cache hit rates for human traffic. ## Implications for Website Operators - Operators face a tradeoff between optimizing infrastructure for human visitors and accommodating AI crawlers. - Some organizations may want to encourage AI access: - Developers may want documentation represented in AI models. - E-commerce companies may want product information included in LLM search results. - Publishers may seek compensation through systems such as pay-per-crawl. - The challenge is supporting useful AI traffic without allowing it to degrade the cache performance experienced by human users. Cloudflare’s analysis, conducted with ETH Zurich researchers, suggests that CDN caching strategies need to evolve beyond traditional assumptions about popularity and reuse. Cache systems designed specifically for AI-era traffic may need to isolate crawler workloads or otherwise prevent broad, low-reuse scans from displacing content valuable to human users.

Read original(opens in new tab)
kakao4 min readCurated summary

From Student to Developer: Learning Rational Choices Over Right Answers—From DB and Security to AI

The onboarding of 40 new Kakao developers shifted their perspective from making features work to designing systems that survive real-world operations. Across databases, security, and AI, they learned that there is rarely one perfect answer; the best choice depends on scale, risk, maintainability, and business needs. The central lesson was to replace theoretical correctness with responsible, adaptable engineering judgment. ## Database: From Finding the Right Answer to Preparing for Change - Database design must be evaluated by whether it can withstand traffic, schema changes, and operational demands—not only by theoretical correctness. - Foreign keys are not automatically the best choice: - They can introduce locking, performance, and flexibility concerns. - Referential integrity can instead be managed at the application layer, provided testing and correction processes are strong. - Soft deletion, using fields such as `deleted_at`, supports auditability and recovery and is often an essential operational strategy. - Indexes should be selected according to the questions the database must answer: - B-tree, GIN, GiST, SP-GiST, and vector indexes serve different data and query patterns. - Execution plans reveal whether SQL uses indexes or performs full table scans, directly affecting I/O and response times. - Duplication is not always harmful: - Intentional denormalization can avoid expensive joins. - Snapshot data can simplify reads and preserve the information needed by a business workflow. - In MongoDB, embedding selected related data can make screen queries much simpler than relying exclusively on references. - Different database systems embody different trade-offs among performance, consistency, scalability, and operational cost. - The training covered MySQL high availability, PostgreSQL primary-key structures, cloud-native systems such as Neon, and the broader storage-to-analysis pipeline of Hadoop and Spark. - The resulting mindset favors designs that are safe to change and affordable to operate over designs that are theoretically perfect. ## Security and IT: From Someone Else’s Responsibility to a Personal Default - Security became a direct consequence of developers’ code rather than merely a compliance or infrastructure concern. - Everyday safeguards such as development/production separation, VPNs, and antivirus software demonstrate that safety often requires accepting some inconvenience. - DDoS defense is not only about blocking traffic: - It can be difficult to distinguish an attack from legitimate traffic spikes caused by a popular event. - Developers should apply basic controls such as rate limiting and escalate suspicious activity through established response channels. - Hands-on API exploitation made vulnerabilities concrete and encouraged developers to view security through an attacker’s perspective. - Security must be continuous: - AI is increasingly being used both to discover vulnerabilities and to strengthen attacks. - Social-engineering methods involving QR codes, app permissions, and human behavior require more than purely technical defenses. - Security checks should be integrated from the beginning of development, not performed only at the end. - Software quality also depends on people: - Code should remain understandable enough for another developer to take over quickly. - Strong engineering means choosing and communicating the most appropriate solution for the business context, not merely finding a technically possible one. ## AI: From Chatting with Models to Designing Systems - An AI agent is not simply a model; it is an architecture composed of tools, routing logic, error handling, and model calls. - Agent development applies familiar software-engineering practices to probabilistic models. - Because LLM outputs can vary, reliable systems need deliberate controls: - Prompt chaining breaks large tasks into smaller steps and limits context contamination. - Few-shot examples clarify required output formats. - Routing selects different prompts or workflows based on conditions. - Multi-agent systems divide responsibilities among specialized agents, echoing the modularity and scalability principles of microservices. - RAG reduces hallucinations structurally by: - Chunking documents. - Searching for semantically similar vectors. - Supplying retrieved information to the model as additional context. - MCP exposes internal systems and data as callable tools, effectively enabling remote function calling and connecting AI to enterprise capabilities. - Effective AI use shifted from criticizing poor answers to specifying clear objectives, formats, examples, context, and supporting data. - The goal is not merely to receive an intelligent response, but to design a system that consistently produces intelligent behavior. The training ultimately marked a transition from student-style problem solving to professional engineering. Developers should consider operational resilience, security, maintainability, and business value, then make and clearly explain the most reasonable choice for the circumstances.

Read original(opens in new tab)
line4 min readCurated summary

Building an Enterprise LLM Service Part

FAA achieves a 96.1% response rate by favoring simple, maintainable techniques over complex AI architectures. Its design choices were to use RAG instead of knowledge-focused fine-tuning, retrieve complete documents before cutting them into question-relevant sections, and rely on a basic ReAct agent loop rather than elaborate workflows or multiple agents. The article concludes that improving documentation is more valuable than adding complexity when unanswered questions mainly result from missing source material. ## RAG Instead of Fine-Tuning - Fine-tuning was rejected as the primary method for injecting enterprise knowledge. - Research cited in the article found that fine-tuning was highly effective for changing a model’s style—about 97% success—but achieved only about 11% accuracy when teaching new factual knowledge. - FAA’s experiment with approximately 40 examples showed that the model answered the exact training question correctly but failed when the wording changed slightly. - Maintaining larger fine-tuning datasets would require experts to create, verify, and continuously update training examples whenever product documentation changes. - RAG is better suited to frequently changing product information because only the source documents need to be updated. - Fine-tuning may still be useful for domain-specific terminology or reasoning patterns, but not for keeping FAA’s product knowledge current. ## Retrieving Whole Documents Instead of Pre-Chunking - Conventional RAG systems split documents into small chunks before embedding them, improving semantic search precision. - Pre-chunking can remove essential context, especially when references such as “this case” or “the following settings” are separated from the text they depend on. - FAA’s documents are generally short, well-structured, focused on one product and topic, making whole-document retrieval practical. - Instead of chunking before search, FAA embeds and retrieves complete documents, then splits them after the relevant document is known. - The post-split process has two stages: - Split the document by Markdown headers into meaningful sections. - Use a lightweight LLM to select only the sections relevant to the user’s question. - For a question about creating and deleting a VM, the main model might receive only the “VM creation” and “VM deletion” sections. - This extra filtering call remains inexpensive because the lightweight model outputs only section indexes rather than generating a full response. - The key advantage is that splitting happens after the system understands the question, preserving context while delivering only the necessary information. ## ReAct Instead of Complex Agent Workflows - FAA tested plan-and-execute workflows, in which the model first creates a multi-step plan and then carries it out. - Planning and replanning increased system complexity without producing a noticeable improvement in answer quality. - With well-designed tools and carefully filtered context, the model was able to determine tool order on its own. - FAA therefore uses ReAct: the model reasons, takes an action, observes the result, and decides what to do next. - This approach allowed the agent to handle troubleshooting questions without a separate planning layer. ## Rejecting Multi-Agent Architectures - The team also tested specialized agents, such as separate VM and Kubernetes experts. - Delegating questions and assembling the results required additional LLM calls, increasing response time from roughly 9 seconds to 14 seconds in one test. - Multi-agent routing performed poorly for cross-domain questions, such as moving data from a VM to object storage. - Specialists could miss information outside their assigned domain, whereas a single agent could maintain the complete context. - FAA therefore kept one agent with access to progressively disclosed tools and relevant documentation. ## Documentation as the Main Bottleneck - Analysis of unanswered questions showed that about 50% were caused by a documentation gap: no reference document existed. - Other failures were mostly temporary API issues or questions outside FAA’s intended scope. - This suggests the core retrieval and agent system performs well when documentation is available. - The team shares missing questions with product teams, whose updated documents are then re-embedded and incorporated into future evaluations. The practical recommendation is to start with the simplest architecture that fits the data: use RAG for changing knowledge, preserve document context during retrieval, and let a capable model operate through a ReAct loop. In enterprise systems, improving the underlying documentation may produce greater gains than adopting more sophisticated AI frameworks.

Read original(opens in new tab)
aws3 min readCurated summary

AWS Weekly Roundup: OpenAI partnership, AWS Elemental Inference, Strands Labs, and more (March 2, 2026) | Amazon Web Services

The March 2, 2026 AWS Weekly Roundup focuses on AWS’s expanding AI ecosystem, including a major strategic partnership with OpenAI and new tools for production AI development. It also highlights services for video transformation, enterprise security, application isolation, and agentic workloads. The broader message is that AWS is moving AI from experimentation toward scalable, enterprise-ready operations. ## OpenAI and AWS Strategic Partnership - Amazon will invest $50 billion in OpenAI: - $15 billion initially. - A further $35 billion subject to conditions. - AWS and OpenAI are developing a Stateful Runtime Environment for OpenAI models through Amazon Bedrock. - The environment allows applications to: - Preserve context and prior work. - Operate across tools and data sources. - Access compute resources. - AWS becomes OpenAI Frontier’s exclusive third-party cloud distribution provider for building and managing AI-agent teams. - The companies are expanding their existing $38 billion agreement by another $100 billion over eight years. - OpenAI plans to consume approximately 2 gigawatts of AWS Trainium capacity, including Trainium3 and Trainium4. ## Major AWS Product Launches - **AWS Security Hub Extended** - Provides integrated procurement and management for partner security products. - Includes vendors such as CrowdStrike, Okta, Splunk, Zscaler, and others. - Offers one AWS bill, pay-as-you-go pricing, unified Security Hub operations, and Level 1 support for Enterprise Support customers. - **AWS Elemental Inference** - Uses AI to transform live and on-demand video for mobile and social platforms. - Automatically creates vertical video for TikTok, Instagram Reels, and YouTube Shorts. - Extracts highlight clips with 6–10 seconds of latency. - Early media customers reported at least 34% savings on AI-powered live video workflows. - **MediaConvert Probe API** - Provides free, rapid media metadata analysis without processing the video. - Returns information such as codecs, pixel formats, and color spaces. - **OpenAI-Compatible Projects API for Amazon Bedrock** - Adds application-level isolation for generative AI workloads. - Improves access control, cost tracking, and organizational observability through OpenAI-compatible APIs. - **Amazon Location Service LLM Context** - Provides curated context for AI agents through Kiro, Claude Code, and the open Agent Skills format. - Helps developers implement location-aware features more accurately. - **Open-Source EKS Node Monitoring Agent** - Makes the agent’s implementation available for inspection, customization, and community contributions. - **AWS AppConfig and New Relic Integration** - Supports automated rollback through New Relic Workflow Automation. - Aims to reduce deployment issue detection and remediation from minutes to seconds. ## Strands Labs and Additional AWS Resources - AWS introduced **Strands Labs**, a separate organization for experimental agentic AI projects. - Its initial projects are: - Robots. - Robots Sim. - AI Functions. - Other highlighted resources cover: - Managing 6,000 AWS accounts with a three-person platform team. - Building event-driven agents with Bedrock AgentCore and Knowledge Bases. - Shifting complexity from application code into platform operations through account-per-tenant architectures. ## AWS Community Highlights - A practical guide for running effective Kiro AI coding workshops. - A comparison of traditional RAG using FAISS with GraphRAG using Neo4j to evaluate hallucination reduction in travel agents. - New AWS CLI v2 output options, including structured error output and the `off` format. ## Upcoming Events - **NVIDIA GTC 2026:** March 16–19 in San Jose, with AWS sessions, demos, and booths. - **AWS Summits:** Paris on April 1, London on April 22, and Bengaluru on April 23–24. - **AWS Community Days:** Events in Tokyo, Chennai, Slovakia, and Pune during March. AWS’s latest announcements point toward a tightly integrated AI platform combining specialized hardware, managed agent infrastructure, enterprise security, and production-focused developer tools. Organizations evaluating AI adoption should watch these services closely, particularly Bedrock’s new stateful and application-isolation capabilities and Elemental Inference’s automated media workflows.

Read original(opens in new tab)
dropbox3 min readCurated summary

Using LLMs to amplify human labeling and improve Dash search relevance

Dropbox Dash improves AI answers through retrieval-augmented generation (RAG): enterprise search retrieves relevant company documents, and an LLM uses a small subset of them to generate grounded responses. Because ranking determines which documents reach the LLM, search relevance depends heavily on high-quality query–document labels. Dash combines a small set of human judgments with large-scale LLM-generated labels to produce training data efficiently while retaining human oversight. ## How Dash search ranking works - Dash uses a trained ranking model, such as XGBoost, rather than manually configured rules. - The model learns from query–document pairs labeled on a 1–5 relevance scale: - **5:** Closely matches the user’s intent. - **1:** Not useful enough to display. - Relevance depends on the query, user context, and timing; it is not an intrinsic property of a document. - Ranking quality is especially important because enterprises may have millions or billions of indexed documents, while only a small selection can be sent to the answer-generating LLM. ## Sources of relevance labels - Labels can come from: - User behavior, such as clicks or skipped results. - Human evaluators assigning relevance scores. - LLMs directly judging query–document relevance. - Behavioral signals are useful but often sparse, biased by existing rankings, and unevenly distributed, so they work best as a supplement. - Human evaluators can provide comprehensive judgments across result sets, but labeling is expensive, difficult to scale, and vulnerable to inconsistency. - Humans also cannot directly review sensitive or proprietary customer data in this process, and different content types—such as Slack messages, Jira tickets, and Salesforce records—require different contextual expertise. ## LLM-assisted relevance evaluation - LLMs can evaluate far larger candidate sets at lower cost and with greater consistency than human annotators. - They can operate across languages and analyze customer content within established compliance boundaries. - Their judgments still depend on the model’s quality and the clarity of the evaluation prompt. - LLM-generated labels therefore require calibration and validation before being used for model training. ## Combining human review with LLM scale - Dropbox first creates a relatively small, high-quality dataset using human evaluators and limited, non-sensitive internal data. - These human labels are used to tune LLM prompts and model parameters. - Once the LLM meets quality thresholds, it generates hundreds of thousands or millions of relevance labels. - This approach multiplies human labeling effort by roughly 100 times, enabling broader and more representative training data. - LLMs are used offline rather than directly at query time because production-time use would introduce excessive latency and context-window limitations. - The LLM acts as a teacher for smaller, faster ranking models that can serve searches at scale. ## Evaluation as the foundation - Dash follows an iterative process: measure performance, change the model or instructions, and measure again. - The article compares this to chess engines, where the quality of the evaluation function determines which possible moves are preserved or discarded. - The same principle applies to ranking: poor relevance judgments can cause useful search-result patterns to be eliminated, while accurate judgments guide the model toward better rankings. Dash’s approach uses humans for quality control and contextual grounding, then uses LLMs to expand that expertise into large-scale training data. This hybrid strategy offers a practical way to improve enterprise search relevance without exposing customer data to human reviewers or imposing LLM latency on every search.

Read original(opens in new tab)
toss4 min readCurated summary

The Software 3.0

The post argues that teams using the same LLM can achieve very different results because individual knowledge of context engineering varies widely. Claude Code’s plugins and marketplace could help turn personal LLM techniques into shared, executable team workflows, raising the organization’s productivity floor. The author presents this as a forward-looking hypothesis rather than a proven success story. ## The Frictionless Harness - LLM adoption loses effectiveness when developers must switch between terminals, browsers, and chat tools. - Claude Code’s terminal-based TUI reduces context switching by combining natural-language instructions and code in the developer’s existing environment. - This low-friction experience makes it easier to distribute standardized workflows across a team. ## Executable Single Source of Truth - Wikis and Notion pages become outdated because they are designed primarily for human reading. - Claude Code plugins can serve as “executable SSOT”: - Humans can read them as guidelines and manuals. - LLMs can interpret them as precise system instructions. - Updating a plugin can immediately change how team agents behave, keeping operational knowledge aligned with current practices. ## Raising the Team’s Productivity Floor - Teams have significant differences in LLM literacy, independent of coding ability. - Generic open-source plugins can provide shared best practices, but they lack company- and domain-specific context. - Each domain needs its own rules for: - Tasks the AI can perform autonomously. - Tasks requiring human approval through HITL processes. - The goal is to minimize human intervention while preserving approval at critical points. ## Extending Platform Engineering into Software 3.0 - AI workflows resemble traditional internal platform components such as authentication, logging, and payment libraries. - The analogy is: - Common software modules → AI workflow plugins - Library distribution → Marketplace publishing - The implementation changes from traditional code to prompts and agent logic. - AI workflows should receive the same quality practices as software modules, including review, optimization, and feedback on token usage and failure cases. - Marketplace-based collaboration could turn individual prompting techniques into shared organizational intelligence. ## Why Use a Marketplace Instead of Only RAG? - RAG systems can make it difficult to predict which context will be retrieved due to search, reranking, and indexing behavior. - Plugins provide more explicit and controllable instructions and code. - Developers can modify and test workflows locally in the TUI without deploying a server. - With the Claude Agent SDK, workflows validated locally could also run in server environments, improving development-production parity. - The marketplace could become the shared source of truth between experimentation and production. ## Marketplace as a Workflow Distribution Platform - Teams could package coding conventions, Git strategies, lint rules, and testing policies into private plugins or registries. - Hooks could actively correct behavior rather than merely reject violations—for example, preventing commits on `main` and creating a `feature/` branch instead. - Slash commands could distribute the best engineer’s workflow to everyone: - `/new-feature` gathers requirements. - Creates a Jira issue and branch. - Produces an implementation plan for approval. - Implements the feature and opens a pull request. - This allows less experienced users to follow a reliable, high-quality process without reproducing it manually. ## Layered Context Architecture The author proposes separating plugin knowledge into three layers: - **Global layer:** Organization-wide security rules and coding standards. - **Domain layer:** Business-specific knowledge for areas such as payments, settlement, or membership. - **Local layer:** Repository-specific implementation details and conventions. This structure avoids overwhelming the LLM with irrelevant information and creates a “living knowledge base” made of maintainable prompts and code rather than static documents. ## The Data Flywheel Hypothesis - Standardized plugins could generate high-quality instruction-tuning data. - Accumulated workflow data might eventually support domain-specific model fine-tuning. - Existing workflows could also provide evaluation criteria for those models. - Success would require sustained data collection, quality controls, and long-term organizational investment. - The proposed flywheel is: more usage creates more data, better data improves models, and better models encourage further usage. The practical recommendation is to treat LLM expertise as an organizational system rather than an individual skill. Teams should begin packaging their implicit knowledge, approval rules, and proven workflows into versioned, domain-aware plugins that can be tested, reviewed, and distributed through a marketplace or private registry.

Read original(opens in new tab)