Agentic RAG: From Static Retrieval to Iterative Reasoning

At the center of this release is the evolution of RAG architectures. Traditional RAG pipelines typically involve static queries to vector stores followed by synthesis via large language models. However, this linear approach often fails in multi-perspective or multi-hop information retrieval.

Agentic RAG reframes the process by introducing autonomous retrieval agents that reason iteratively and adjust their behavior based on intermediate results. These agents improve retrieval precision and adaptability through:

• Context-Aware Query Expansion: Agents reformulate search queries dynamically based on evolving task context.
• Multi-Step Decomposition: Complex queries are broken into logical subtasks, each addressed in sequence.
• Adaptive Source Selection: Instead of querying a fixed vector store, agents select optimal sources contextually.
• Fact Verification: Dedicated evaluator agents validate retrieved content for consistency and grounding before synthesis.

The net result is a more intelligent RAG pipeline, capable of responding to nuanced information needs in high-stakes domains such as healthcare, legal compliance, and financial intelligence.

Rigorous Evaluation of Agent Behavior

Evaluating the performance of AI agents requires a distinct methodology from that used for static LLM outputs. Google’s framework separates agent evaluation into three primary dimensions:

1. Capability Assessment: Benchmarking the agent’s ability to follow instructions, plan, reason, and use tools. Tools like AgentBench, PlanBench, and BFCL are highlighted for this purpose.
2. Trajectory and Tool Use Analysis: Instead of focusing solely on outcomes, developers are encouraged to trace the agent’s action sequence (trajectory) and compare it to expected behavior using precision, recall, and match-based metrics.
3. Final Response Evaluation: Evaluation of the agent’s output through autoraters—LLMs acting as evaluators—and human-in-the-loop methods. This ensures that assessments include both objective metrics and human-judged qualities like helpfulness and tone.

This process enables observability across both the reasoning and execution layers of agents, which is critical for production deployments.

Scaling to Multi-Agent Architectures

As real-world systems grow in complexity, Google’s whitepaper emphasizes a shift toward multi-agent architectures, where specialized agents collaborate, communicate, and self-correct.

Key benefits include:

• Modular Reasoning: Tasks are decomposed across planner, retriever, executor, and validator agents.
• Fault Tolerance: Redundant checks and peer hand-offs increase system reliability.
• Improved Scalability: Specialized agents can be independently scaled or replaced.

Evaluation strategies adapt accordingly. Developers must track not only final task success but also coordination quality, adherence to delegated plans, and agent utilization efficiency. Trajectory analysis remains the primary lens, extended across multiple agents for system-level evaluation.

Real-World Applications: From Enterprise Automation to Automotive AI

The second half of the whitepaper focuses on real-world implementation patterns:

AgentSpace and NotebookLM Enterprise

Google’s AgentSpace is introduced as an enterprise-grade orchestration and governance platform for agent systems. It supports agent creation, deployment, and monitoring, incorporating Google Cloud’s security and IAM primitives. NotebookLM Enterprise, a research assistant framework, enables contextual summarization, multimodal interaction, and audio-based information synthesis.

Automotive AI Case Study

A highlight of the paper is a fully implemented multi-agent system within a connected vehicle context. Here, agents are designed for specialized tasks—navigation, messaging, media control, and user support—organized using design patterns such as:

• Hierarchical Orchestration: Central agent routes tasks to domain experts.
• Diamond Pattern: Responses are refined post-hoc by moderation agents.
• Peer-to-Peer Handoff: Agents detect misclassification and reroute queries autonomously.
• Collaborative Synthesis: Responses are merged across agents via a Response Mixer.
• Adaptive Looping: Agents iteratively refine results until satisfactory outputs are achieved.

This modular design allows automotive systems to balance low-latency, on-device tasks (e.g., climate control) with more resource-intensive, cloud-based reasoning (e.g., restaurant recommendations).

Check out the Full Guide here. Also, don’t forget to follow us on Twitter.

Here’s a brief overview of what we’re building at Marktechpost:

• Newsletter– airesearchinsights.com/(30k+ subscribers)
• miniCON AI Events – minicon.marktechpost.com
• AI Reports & Magazines – magazine.marktechpost.com
• AI Dev & Research News – marktechpost.com (1M+ monthly readers)
• ML News Community – r/machinelearningnews (92k+ members)

The post Google Releases 76-Page Whitepaper on AI Agents: A Deep Technical Dive into Agentic RAG, Evaluation Frameworks, and Real-World Architectures appeared first on MarkTechPost.

Furthermore, existing surveys tend to address only specific subtopics within the broader memory landscape, such as long-context handling, long-term memory, personalization, or knowledge editing. These fragmented approaches often miss essential operations like indexing and fail to offer comprehensive overviews of memory dynamics. Additionally, most prior work does not establish a clear research scope or provide structured benchmarks and tool coverage, limiting their practical value for guiding future advancements in memory for AI systems. 

Researchers from the Chinese University, the University of Edinburgh, HKUST, and the Poisson Lab at Huawei UK R&D Ltd. present a detailed survey on memory in AI systems. They classify memory into parametric, contextual-structured, and contextual-unstructured types, distinguishing between short-term and long-term memory inspired by cognitive psychology. Six fundamental operations—consolidation, updating, indexing, forgetting, retrieval, and compression—are defined and mapped to key research areas, including long-term memory, long-context modeling, parametric modification, and multi-source integration. Based on an analysis of over 30,000 papers using the Relative Citation Index, the survey also outlines tools, benchmarks, and future directions. 

The researchers first develop a three‐part taxonomy of AI memory—parametric (model weights), contextual‐structured (e.g., indexed dialogue histories), and contextual‐unstructured (raw text or embeddings)—and distinguish short‐ versus long‐term spans. They then define six core memory operations: consolidation (storing new information), updating (modifying existing entries), indexing (organizing for fast access), forgetting (removing stale data), retrieval (fetching relevant content), and compression (distilling memories). To ground this framework, they mined over 30,000 top‐tier AI papers (2022–2025), ranked them by Relative Citation Index, and clustered high‐impact works into four themes—long‐term memory, long‐context modeling, parametric editing, and multi‐source integration—thereby mapping each operation and memory type to active research areas and highlighting key benchmarks and tools. 

The study describes a layered ecosystem of memory-centric AI systems that support long-term context management, user modeling, knowledge retention, and adaptive behavior. This ecosystem is structured across four tiers: foundational components (such as vector stores, large language models like Llama and GPT-4, and retrieval mechanisms like FAISS and BM25), frameworks for memory operations (e.g., LangChain and LlamaIndex), memory layer systems for orchestration and persistence (such as Memary and Memobase), and end-user-facing products (including Me. bot and ChatGPT). These tools provide infrastructure for memory integration, enabling capabilities like grounding, similarity search, long-context understanding, and personalized AI interactions.

The survey also discusses open challenges and future research directions in AI memory. It highlights the importance of spatio-temporal memory, which balances historical context with real-time updates for adaptive reasoning. Key challenges include parametric memory retrieval, lifelong learning, and efficient knowledge management across memory types. Additionally, the paper draws inspiration from biological memory models, emphasizing dual-memory architectures and hierarchical memory structures. Future work should focus on unifying memory representations, supporting multi-agent memory systems, and addressing security concerns, particularly memory safety and malicious attacks in machine learning techniques. 

Check out the Paper. Also, don’t forget to follow us on Twitter and join our Telegram Channel and LinkedIn Group. Don’t Forget to join our 90k+ ML SubReddit. For Promotion and Partnerships, please talk us.

[Register Now] miniCON Virtual Conference on AGENTIC AI: FREE REGISTRATION + Certificate of Attendance + 4 Hour Short Event (May 21, 9 am- 1 pm PST) + Hands on Workshop

The post How AI Agents Store, Forget, and Retrieve? A Fresh Look at Memory Operations for the Next-Gen LLMs appeared first on MarkTechPost.

FastAPI-MCP: Native FastAPI Extension

FastAPI-MCP is an open-source library that integrates directly with Python’s FastAPI framework. All existing REST routes become MCP tools by instantiating a single class and mounting it on your FastAPI app. Input and output schemas defined via Pydantic models carry over automatically, and the tool descriptions derive from your route documentation. Authentication and dependency injection behave exactly as in normal FastAPI endpoints, ensuring that any security or validation logic you already have remains effective.

Under the hood, FastAPI-MCP hooks into the ASGI application and routes MCP protocol calls to the appropriate FastAPI handlers in-process. This avoids extra HTTP overhead and keeps performance high. Developers install it via pip, add a minimal snippet such as:

from fastapi import FastAPI
from fastapi_mcp import FastApiMCP

app = FastAPI()
mcp = FastApiMCP(app)
mcp.mount(path="/mcp")

The resulting MCP server can run on the same Uvicorn process or separately. Because it is fully open-source under the MIT license, teams can audit, extend, or customize it as needed.

RapidMCP: Zero-Code REST-to-MCP Conversion Service

RapidMCP provides a hosted, no-code pathway to transform existing REST APIs, particularly those with OpenAPI specifications, into MCP servers without changing backend code. After registering an account, a developer points RapidMCP at their API’s base URL or uploads an OpenAPI document. RapidMCP then spins up an MCP server in the cloud that proxies tool calls back to the original API.

Each route becomes an MCP tool whose arguments and return types reflect the API’s parameters and responses. Because RapidMCP sits in front of your service, it can supply usage analytics, live tracing of AI calls, and built-in rate limiting. The platform also plans self-hosting options for enterprises that require on-premises deployments. Teams who prefer a managed experience can go from API to AI-agent compatibility in under an hour, at the expense of trusting a third-party proxy.

MCPify: No-Code MCP Server Builder with AI Assistant

MCPify is a fully managed, no-code environment where users describe desired functionality in natural language, such as “fetch current weather for a given city”, and an AI assistant generates and hosts the corresponding MCP tools. The service hides all code generation, infrastructure provisioning, and deployment details. Users interact via a chat or form interface, review automatically generated tool descriptions, and deploy with a click.

Because MCPify leverages large language models to assemble integrations on the fly, it excels at rapid prototyping and empowers non-developers to craft AI-accessible services. It supports common third-party APIs, offers one-click sharing of created servers with other platform users, and automatically handles protocol details such as streaming responses and authentication. The trade-off is less direct control over the code and reliance on a closed-source hosted platform.

Speakeasy: OpenAPI-Driven SDK and MCP Server Generator

Speakeasy is known for generating strongly typed client SDKs from OpenAPI specifications, and it extends this capability to MCP by producing a fully functional TypeScript MCP server alongside each SDK. After supplying an OpenAPI 3.x spec to Speakeasy’s code generator, teams receive:

• A typed client library for calling the API
• Documentation derived directly from the spec
• A standalone MCP server implementation in TypeScript

The generated server wraps each API endpoint as an MCP tool, preserving descriptions and models. Developers can run the server via a provided CLI or compile it to a standalone binary. Because the output is actual code, teams have full visibility and can customize behavior, add composite tools, enforce scopes or permissions, and integrate custom middleware. This approach is ideal for organizations with mature OpenAPI workflows that want to offer AI-ready access in a controlled, maintainable way.

Higress MCP Marketplace: Open-Source API Gateway at Scale

Higress is an open-source API gateway built atop Envoy and Istio, extended to support the MCP protocol. Its conversion tool takes an OpenAPI spec and generates a declarative YAML configuration that the gateway uses to host an MCP server. Each API operation becomes a tool with templates for HTTP requests and response formatting, all defined in configuration rather than code. Higress powers a public “MCP Marketplace” where multiple APIs are published as MCP servers, enabling AI clients to discover and consume them centrally. Enterprises can self-host the same infrastructure to expose hundreds of internal services via MCP. The gateway handles protocol version upgrades, rate limiting, authentication, and observability. It is particularly well suited for large-scale or multi-API environments, turning API-MCP conversions into a configuration-driven process that integrates seamlessly with infrastructure-as-code pipelines.

Django-MCP: Plugin for Django REST Framework

Django-MCP is an open-source plugin that brings MCP support to the Django REST Framework (DRF). By applying a mixin to your view sets or registering an MCP router, it automatically exposes DRF endpoints as MCP tools. It introspects serializers to derive input schemas and uses your existing authentication backends to secure tool invocations. Underneath, MCP calls are translated into normal DRF viewset actions, preserving pagination, filtering, and validation logic.

Installation requires adding the package to your requirements, including the Django-MCP application, and configuring a route:

from django.urls import path
from django_mcp.router import MCPRouter

router = MCPRouter()
router.register_viewset('mcp', MyModelViewSet)

urlpatterns = [
    path('api/', include(router.urls)),
]

This approach allows teams already invested in Django to add AI-agent compatibility without duplicating code. It also supports custom tool annotations via decorators for fine-tuned naming or documentation.

GraphQL-MCP: Converting GraphQL Endpoints to MCP

GraphQL-MCP is a community-driven library that wraps a GraphQL server and exposes its queries and mutations as individual MCP tools. It parses the GraphQL schema to generate tool manifests, mapping each operation to a tool name and input type. When an AI agent invokes a tool, GraphQL-MCP constructs and executes the corresponding GraphQL query or mutation, then returns the results in a standardized JSON format expected by MCP clients. This solution is valuable for organizations using GraphQL who want to leverage AI agents without settling on a REST convention or writing bespoke GraphQL calls. It supports features like batching, authentication via existing GraphQL context mechanisms, and schema stitching to combine GraphQL services under one MCP server.

gRPC-MCP: Bridging gRPC Services for AI Agents

gRPC-MCP focuses on exposing high-performance gRPC services to AI agents through MCP. It uses protocol buffers’ service definitions to generate an MCP server that accepts JSON-RPC-style calls, internally marshals them to gRPC requests, and streams responses. Developers include a small adapter in their gRPC server code:

import "google.golang.org/grpc"
import "grpc-mcp-adapter"

func main() {
  srv := grpc.NewServer()
  myService.RegisterMyServiceServer(srv, &MyServiceImpl{})
  mcpAdapter := mcp.NewAdapter(srv)
  http.Handle("/mcp", mcpAdapter.Handler())
  log.Fatal(http.ListenAndServe(":8080", nil))
}

This makes it easy to bring low-latency, strongly typed services into the MCP ecosystem, opening the door for AI agents to call business-critical gRPC methods directly.

Choosing the Right Tool

Selecting among these eight solutions depends on several factors:

• Preferred development workflow: FastAPI-MCP and Django-MCP for code-first integration, Speakeasy for spec-driven code generation, GraphQL-MCP or gRPC-MCP for non-REST paradigms.
• Control versus convenience: Libraries like FastAPI-MCP, Django-MCP, and Speakeasy give full code control, while hosted platforms like RapidMCP and MCPify trade off some control for speed and ease.
• Scale and governance: Higress shines when converting and managing large numbers of APIs in a unified gateway, with built-in routing, security, and protocol upgrades.
• Rapid prototyping: MCPify’s AI assistant allows non-developers to spin up MCP servers instantly, which is ideal for experimentation and internal automation.

All these tools adhere to the evolving MCP specification, ensuring interoperability among AI agents and services. By choosing the right converter, API providers can accelerate the adoption of AI-driven workflows and empower agents to orchestrate real-world capabilities safely and efficiently.

The post 8 Comprehensive Open-Source and Hosted Solutions to Seamlessly Convert Any API into AI-Ready MCP Servers appeared first on MarkTechPost.

Model Context Protocol (MCP): An Overview  

The Model Context Protocol (MCP) was introduced to standardize how AI agents discover and invoke external tools and data sources. MCP is an open protocol that defines a common JSON-RPC-based API layer between LLM hosts and servers. In effect, MCP acts like a “USB-C port for AI applications”, a universal interface that any model can use to access tools. MCP enables secure, two-way connections between an organization’s data sources and AI-powered tools, replacing the piecemeal connectors of the past. Crucially, MCP decouples the model from the tools. Instead of writing model-specific prompts or hard-coding function calls, an agent simply connects to one or more MCP servers, each of which exposes data or capabilities in a standardized way. The agent (or host) retrieves a list of available tools, including their names, descriptions, and input/output schemas, from the server. The model can then invoke any tool by name. This standardization and reuse are a core advantage over prior approaches.

MCP’s open specification defines three core roles:

• Host – The LLM application or user interface (e.g., a chat UI, IDE, or agent orchestration engine) that the user interacts with. The host embeds the LLM and acts as an MCP client.
• Client – The software module within the host that implements the MCP protocol (typically via SDKs). The client handles messaging, authentication, and marshalling model prompts and responses.
• Server – A service (local or remote) that provides context and tools. Each MCP server may wrap a database, API, codebase, or other system, and it advertises its capabilities to the client.

MCP was explicitly inspired by the Language Server Protocol (LSP) used in IDEs: just as LSP standardizes how editors query language features, MCP standardizes how LLMs query contextual tools. By using a common JSON-RPC 2.0 message format, any client and server that adheres to MCP can interoperate, regardless of the programming language or LLM used.

Technical Design and Architecture of MCP  

MCP relies on JSON-RPC 2.0 to carry three types of messages, requests, responses, and notifications, allowing agents to perform both synchronous tool calls and receive asynchronous updates. In local deployments, the client often spawns a subprocess and communicates over stdin/stdout (the stdio transport). In contrast, remote servers typically use HTTP with Server-Sent Events (SSE) to stream messages in real-time. This flexible messaging layer ensures that tools can be invoked and results delivered without blocking the host application’s main workflow. 

Under the MCP specification, every server exposes three standardized entities: resources, tools, and prompts. Resources are fetchable pieces of context, such as text files, database tables, or cached documents, that the client can retrieve by ID. Tools are named functions with well-defined input and output schemas, whether that’s a search API, a calculator, or a custom data-processing routine. Prompts are optional, higher-level templates or workflows that guide the model through multi-step interactions. By providing JSON schemas for each entity, MCP enables any capable large language model (LLM) to interpret and invoke these capabilities without requiring bespoke parsing or hard-coded integrations. 

The MCP architecture cleanly separates concerns across three roles. The host embeds the LLM and orchestrates conversation flow, passing user queries into the model and handling its outputs. The client implements the MCP protocol itself, managing all message marshalling, authentication, and transport details. The server advertises available resources and tools, executes incoming requests (for example, listing tools or performing a query), and returns structured results. This modular design, encompassing AI and UI in the host, protocol logic in the client, and execution in the server, ensures that systems remain maintainable, extensible, and easy to evolve.

Interaction Model and Agent Workflows  

Using MCP in an agent follows a simple pattern of discovery and execution. When the agent connects to an MCP server, it first calls the ‘list_tools()’ method to retrieve all available tools and resources. The client then integrates these descriptions into the LLM’s context (e.g., by formatting them into the prompt). The model now knows that these tools exist and what parameters they take. When the agent decides to use a tool (often prompted by a user’s query), the LLM emits a structured call (e.g., a JSON object with ‘”call”: “tool_name”, “args”: {…}’). The host recognizes this as a tool invocation, and the client issues a corresponding ‘call_tool()’ request to the server. The server executes the tool and sends back the result. The client then feeds this result into the model’s next prompt, making it appear as additional context.

This workflow replaces brittle ad-hoc parsing. The Agents SDK will call ‘list_tools()’ on MCP servers each time the agent is run, making the LLM aware of the server’s tools. When the LLM calls a tool, the SDK calls the ‘call_tool()’ function on the server behind the scenes. This protocol transparently handles the loop of discover→prompt→tool→respond. Furthermore, MCP supports composable workflows. Servers can define multi-step prompt templates, where the output of one tool serves as the input for another, enabling the agent to execute complex sequences. Future versions of MCP and related SDKs will already be adding features such as long-running sessions, stateful interactions, and scheduled tasks.

Implementations and Ecosystem  

MCP is implementation-agnostic. The official specification is maintained on GitHub, and multiple language SDKs are available, including TypeScript, Python, Java, Kotlin, and C#. Developers can write MCP clients or servers in their preferred stack. For example, the OpenAI Agents SDK includes classes that enable easy connection to standard MCP servers from Python. InfraCloud’s tutorial demonstrates setting up a Node.js-based file-system MCP server to allow an LLM to browse local files.

A growing number of MCP servers have been published as open source. Anthropic has released connectors for many popular services, including Google Drive, Slack, GitHub, Postgres, MongoDB, and web browsing with Puppeteer, among others. Once one team builds a server for Jira or Salesforce, any compliant agent can use it without rework. On the client/host side, many agent platforms have integrated MCP support. Claude Desktop can attach to MCP servers. Google’s Agent Development Kit treats MCP servers as tool providers for Gemini models. Cloudflare’s Agents SDK added an McpAgent class so that any FogLAMP can become an MCP client with built-in auth support. Even auto-agents like Auto-GPT can plug into MCP: instead of coding a specific function for each API, the agent uses an MCP client library to call tools. This trend toward universal connectors promises a more modular autonomous agent architecture.

In practice, this ecosystem enables any given AI assistant to connect to multiple data sources simultaneously. One can imagine an agent that, in one session, uses an MCP server for corporate docs, another for CRM queries, and yet another for on-device file search. MCP even handles naming collisions gracefully: if two servers each have a tool called ‘analyze’, clients can namespace them (e.g., ‘ImageServer.analyze’ vs ‘CodeServer.analyze’) so both remain available without conflict.

Advantages of MCP Over Prior Paradigms  

MCP brings several key benefits that earlier methods lack:

• Standardized Integration: MCP provides a single protocol for all tools. Whereas each framework or model previously had its way of defining tools, MCP means that the tool servers and clients agree on JSON schemas. This eliminates the need for separate connectors per model or per agent, streamlining development and eliminating the need for custom parsing logic for each tool’s output.
• Dynamic Tool Discovery: Agents can discover tools at runtime by calling ‘list_tools()’ and dynamically learning about available capabilities. There is no need to restart or reprogram the model when a new tool is added. This flexibility stands in contrast to frameworks where available tools are hardcoded at startup.
• Interoperability and Reuse: Because MCP is model-agnostic, the same tool server can serve multiple LLM clients. With MCP, an organization can implement a single connector for a service and have it work with any compliant LLM, thereby avoiding vendor lock-in and reducing duplicate engineering efforts.
• Scalability and Maintenance: MCP dramatically reduces duplicated work. Rather than writing ten different file-search functions for ten models, developers write one MCP file-search server. Updates and bug fixes to that server benefit all agents across all models.
• Composable Ecosystem: MCP enables a marketplace of independently developed servers. Companies can publish MCP connectors for their software, allowing any AI to integrate with their data. This encourages an open ecosystem of connectors analogous to web APIs.
• Security and Control: The protocol supports clear authorization flows. MCP servers describe their tools and required scopes, and hosts must obtain user consent before exposing data. This explicit approach improves auditability and security compared to free-form prompting.

Industry Impact and Real-World Applications  

MCP adoption is growing rapidly. Major vendors and frameworks have publicly invested in MCP or related agent standards. Organizations are exploring MCP to integrate internal systems, such as CRM, knowledge bases, and analytics platforms, into AI assistants.

Concrete use cases include:

• Developer Tools: Code editors and search platforms (e.g., Zed, Replit, Sourcegraph) utilize MCP to enable assistants to query code repositories, documentation, and commit history, resulting in richer code completion and refactoring suggestions.
• Enterprise Knowledge & Chatbots: Helpdesk bots can access Zendesk or SAP data via MCP servers, answering questions about open tickets or generating reports based on real-time enterprise data, all with built-in authorization and audit trails.
• Enhanced Retrieval-Augmented Generation: RAG agents can combine embedding-based retrieval with specialized MCP tools for database queries or graph searches, thereby overcoming the limitations of LLMs in terms of factual accuracy and arithmetic.
• Proactive Assistants: Event-driven agents monitor email or task streams and autonomously schedule meetings or summarize action items by calling calendar and note-taking tools through MCP.

In each scenario, MCP enables agents to scale across diverse systems without requiring the rewriting of integration code, delivering maintainable, secure, and interoperable AI solutions.

Comparisons with Prior Paradigms  

• Versus ReAct: ReAct-style prompting embeds action instructions directly into free text, requiring developers to parse model outputs and manually handle each action. MCP provides the model with a formal interface using JSON schemas, enabling clients to manage execution seamlessly.
• Versus Toolformer: Toolformer ties tool knowledge to the model’s training data, necessitating retraining for new tools. MCP externalizes tool interfaces entirely from the model, enabling zero-shot support for any registered tool without retraining.
• Versus Framework Libraries: Libraries like LangChain simplify building agent loops but still require hardcoded connectors. MCP shifts integration logic into a reusable protocol, making agents more flexible and reducing code duplication.
• Versus Autonomous Agents: Auto-GPT agents typically bake tool wrappers and loop logic into Python scripts. By using MCP clients, such agents need no bespoke code for new services, instead relying on dynamic discovery and JSON-RPC calls.
• Versus Function-Calling APIs: While modern LLM APIs offer function-calling capabilities, they remain model-specific and are limited to single turns. MCP generalizes function calling across any client and server, with support for streaming, discovery, and multiplexed services.

MCP thus unifies and extends previous approaches, offering dynamic discovery, standardized schemas, and cross-model interoperability in a single protocol.

Limitations and Challenges  

Despite its promise, MCP is still maturing:

• Authentication and Authorization: The spec leaves auth schemes to implementations. Current solutions require layering OAuth or API keys externally, which can complicate deployments without a unified auth standard.
• Multi-step Workflows: MCP focuses on discrete tool calls. Orchestrating long-running, stateful workflows often still relies on external schedulers or prompt chaining, as the protocol lacks a built-in session concept.
• Discovery at Scale: Managing many MCP server endpoints can be burdensome in large environments. Proposed solutions include well-known URLs, service registries, and a central connector marketplace, but these are not yet standardized.
• Ecosystem Maturity: MCP is new, so not every tool or data source has an existing connector. Developers may need to build custom servers for niche systems, although the protocol’s simplicity keeps that effort relatively low.
• Development Overhead: For single, simple tool calls, the MCP setup can feel heavyweight compared to a quick, direct API call. MCP’s benefits accrue most in multi-tool, long-lived production systems rather than short experiments.

Many of these gaps are already being addressed by contributors and vendors, with plans to add standardized auth extensions, session management, and discovery infrastructure.

In conclusion, the Model Context Protocol represents a significant milestone in AI agent design, offering a unified, extensible, and interoperable approach for LLMs to access external tools and data sources. By standardizing discovery, invocation, and messaging, MCP eliminates the need for custom connectors per model or framework, enabling agents to integrate diverse services seamlessly. Early adopters across development tools, enterprise chatbots, and proactive assistants are already reaping the benefits of maintainability, scalability, and security that MCP offers. As MCP evolves, adding richer auth, session support, and registry services, it is poised to become the universal standard for AI connectivity, much like HTTP did for the web. For researchers, developers, and technology leaders alike, MCP opens the door to more powerful, flexible, and future-proof AI solutions.

Sources

• https://modelcontextprotocol.io/specification/2025-03-26   
• https://modelcontextprotocol.io/introduction 
• https://python.langchain.com/docs/concepts/tool_calling/ 
• https://www.anthropic.com/news/model-context-protocol 
• https://openai.github.io/openai-agents-python/mcp/ 
• https://arxiv.org/abs/2210.03629   
• https://arxiv.org/abs/2302.04761 
• https://arxiv.org/html/2404.04442v1

The post How the Model Context Protocol (MCP) Standardizes, Simplifies, and Future-Proofs AI Agent Tool Calling Across Models for Scalable, Secure, Interoperable Workflows Traditional Approaches to AI–Tool Integration appeared first on MarkTechPost.

To address this, recent research emphasizes the need for adaptive RAG systems to determine the appropriate modality and retrieval granularity based on the query context. Strategies include routing queries based on complexity, such as deciding between no retrieval, single-step, or multi-step retrieval, and using model confidence to trigger retrieval only when needed. Furthermore, the granularity of retrieval plays a crucial role, as studies have shown that indexing corpora at finer levels, like propositions or specific video clips, can significantly improve retrieval relevance and system performance. Hence, for RAG to truly support complex, real-world information needs, it must handle multiple modalities and adapt its retrieval depth and scope to the specific demands of each query. 

Researchers from KAIST and DeepAuto.ai introduce UniversalRAG, a RAG framework that retrieves and integrates knowledge from various modality-specific sources (text, image, video) and multiple granularity levels. Unlike traditional approaches that embed all modalities into a shared space, leading to modality bias, UniversalRAG uses a modality-aware routing mechanism to select the most relevant corpus dynamically based on the query. It further enhances retrieval precision by organizing each modality into granularity-specific corpora, such as paragraphs or video clips. Validated on eight multimodal benchmarks, UniversalRAG consistently outperforms unified and modality-specific baselines, demonstrating its adaptability to diverse query needs. 

UniversalRAG is a retrieval-augmented generation framework that handles queries across various modalities and data granularities. Unlike standard RAG models limited to a single corpus, UniversalRAG separates knowledge into text, image, and video corpora, each with fine- and coarse-grained levels. A routing module first determines the optimal modality and granularity for a given query, choosing among options like paragraphs, full documents, video clips, or full video, and retrieves relevant information accordingly. This router can be either a training-free LLM-based classifier or a trained model using heuristic labels from benchmark datasets. An LVLM then uses the selected content to generate the final response. 

The experimental setup assesses UniversalRAG across six retrieval scenarios: no retrieval, paragraph, document, image, clip, and video. For no-retrieval, MMLU tests general knowledge. Paragraph-level tasks use SQuAD and Natural Questions, while HotpotQA handles multi-hop document retrieval. Image-based queries come from WebQA, and video-related ones are sourced from LVBench and VideoRAG datasets, split into clip- and full-video levels. Corresponding retrieval corpora are curated for each modality—Wikipedia-based for text, WebQA for images, and YouTube videos for video tasks. This comprehensive benchmark ensures robust evaluation across varied modalities and retrieval granularities.

In conclusion, UniversalRAG is a Retrieval-Augmented Generation framework that can retrieve knowledge from multiple modalities and levels of granularity. Unlike existing RAG methods that rely on a single, often text-only, corpus or a single-modality source, UniversalRAG dynamically routes queries to the most appropriate modality- and granularity-specific corpus. This approach addresses issues like modality gaps and rigid retrieval structures. Evaluated on eight multimodal benchmarks, UniversalRAG outperforms both unified and modality-specific baselines. The study also emphasizes the benefits of fine-grained retrieval and highlights how both trained and train-free routing mechanisms contribute to robust, flexible multimodal reasoning. 

Check out the Paper. Also, don’t forget to follow us on Twitter and join our Telegram Channel and LinkedIn Group. Don’t Forget to join our 90k+ ML SubReddit. For Promotion and Partnerships, please talk us.

[Register Now] miniCON Virtual Conference on AGENTIC AI: FREE REGISTRATION + Certificate of Attendance + 4 Hour Short Event (May 21, 9 am- 1 pm PST) + Hands on Workshop

The post Multimodal Queries Require Multimodal RAG: Researchers from KAIST and DeepAuto.ai Propose UniversalRAG—A New Framework That Dynamically Routes Across Modalities and Granularities for Accurate and Efficient Retrieval-Augmented Generation appeared first on MarkTechPost.

Research in diagnostic conversational agents began with rule-based systems like MYCIN, but recent developments have focused on LLMs capable of emulating clinical reasoning. While multimodal AI systems, such as vision-language models, have demonstrated success in radiology and dermatology, integrating these capabilities into conversational diagnostics remains challenging. Effective AI-based diagnostic tools must handle the complexity of multimodal reasoning and uncertainty-driven information gathering, a step beyond merely answering isolated questions. Evaluation frameworks like OSCEs and platforms such as AgentClinic provide useful starting points, yet tailored metrics are still needed to assess performance in multimodal diagnostic contexts. Moreover, while messaging apps are increasingly used in low-resource settings for sharing clinical data, concerns about data privacy, integration with formal health systems, and policy compliance persist. 

Google DeepMind and Google Research have enhanced the AMIE with multimodal capabilities for improved conversational diagnosis and management. Using Gemini 2.0 Flash, AMIE employs a state-aware dialogue framework that adapts conversation flow based on patient state and diagnostic uncertainty, allowing strategic, structured history-taking with multimodal inputs like skin images, ECGs, and documents. AMIE outperformed or matched primary care physicians in a randomized OSCE-style study with 105 scenarios and 25 patient actors across 29 of 32 clinical metrics and 7 of 9 multimodal-specific criteria, demonstrating strong diagnostic accuracy, reasoning, communication, and empathy. 

The study enhances the AMIE diagnostic system by incorporating multimodal perception and a state-aware dialogue framework that guides conversations through phases of history taking, diagnosis, and follow-up. Gemini 2.0 Flash powers the system and dynamically adapts based on evolving patient data, including text, images, and clinical documents. A structured patient profile and differential diagnosis are updated throughout the interaction, with targeted questions and multimodal data requests guiding clinical reasoning. Evaluation includes automated perception tests on isolated artifacts, simulated dialogues rated by auto-evaluators, and expert OSCE-style assessments, ensuring robust diagnostic performance and clinical realism. 

The results show that the multimodal AMIE system performs at par or better than primary care physicians (PCPs) across multiple clinical tasks in simulated text-chat consultations. In OSCE-style assessments, AMIE consistently outperformed PCPs in diagnostic accuracy, especially when interpreting multimodal data such as images and clinical documents. It also demonstrated greater robustness when image quality was poor and showed fewer hallucinations. Patient actors rated AMIE’s communication skills highly, including empathy and trust. Automated evaluations confirmed that AMIE’s advanced reasoning framework, built on the Gemini 2.0 Flash model, significantly improved diagnosis and conversation quality, validating its design and effectiveness in real-world clinical scenarios. 

In conclusion, the study advances conversational diagnostic AI by enhancing AMIE to integrate multimodal reasoning within patient dialogues. Using a novel state-aware inference-time strategy with Gemini 2.0 Flash, AMIE can interpret and reason about medical artifacts like images or ECGs in real-time clinical conversations. Evaluated through a multimodal OSCE framework, AMIE outperformed or matched primary care physicians in diagnostic accuracy, empathy, and artifact interpretation, even in complex cases. Despite limitations tied to chat-based interfaces and the need for real-world testing, these findings highlight AMIE’s potential as a robust, context-aware diagnostic assistant for future telehealth applications. 

Check out the Paper and Technical details. Also, don’t forget to follow us on Twitter and join our Telegram Channel and LinkedIn Group. Don’t Forget to join our 90k+ ML SubReddit. For Promotion and Partnerships, please talk us.

[Register Now] miniCON Virtual Conference on AGENTIC AI: FREE REGISTRATION + Certificate of Attendance + 4 Hour Short Event (May 21, 9 am- 1 pm PST) + Hands on Workshop

The post Google Researchers Advance Diagnostic AI: AMIE Now Matches or Outperforms Primary Care Physicians Using Multimodal Reasoning with Gemini 2.0 Flash appeared first on MarkTechPost.

In contrast to the extensive research on data selection in supervised fine-tuning and human feedback-based reinforcement learning, the role of data in RLVR has seen limited exploration. While LIMR demonstrated that using a small subset of data (1.4k out of 8.5k examples) could maintain performance, it did not examine the extreme case of minimal data use. Another concurrent study found that even training with just four PPO examples led to notable improvements, but this finding wasn’t deeply investigated or benchmarked against full-dataset performance. Although RLVR shows great promise for enhancing reasoning in LLMs, a deeper, systematic study of data efficiency and selection in this context is still lacking. 

Researchers from the University of Washington, University of Southern California, Microsoft, University of California, Santa Cruz, and Georgia Institute of Technology show that RLVR can significantly enhance large language models’ mathematical reasoning using a single training example, 1-shot RLVR. Applying it to Qwen2.5-Math-1.5B improves its MATH500 accuracy from 36.0% to 73.6%, matching the performance of much larger datasets. The improvements generalize across models, tasks, and algorithms. The study also reveals effects like cross-domain generalization, increased self-reflection, and post-saturation generalization, and highlights the roles of policy gradient loss and entropy-driven exploration. 

The study investigates how much the RLVR training dataset can be reduced while retaining comparable performance to the full dataset. Remarkably, the authors find that a single training example—1-shot RLVR—can significantly boost mathematical reasoning in LLMs. The study shows that this effect generalizes across tasks, models, and domains. Interestingly, training on one example often enhances performance on unrelated domains. A simple data selection strategy based on training accuracy variance is proposed, but results show that even randomly chosen examples can yield major gains. 

The study evaluates their method using Qwen2.5-Math-1.5B as the primary model and other models like Qwen2.5-Math-7B, Llama-3.2-3 B-Instructt, and DeepSeek-R1-DistillQwen-1.5 BB. They use a 1,209-example subset of the DeepScaleR dataset for data selection, and the MATH dataset for comparison. Training involves the Verl pipeline, with carefully chosen hyperparameters and batch configurations. Surprisingly, training with just one or two examples—especially π1 and π13—leads to strong generalization, even beyond math tasks. This “post-saturation generalization” persists despite overfitting signs. The study also finds increased model self-reflection and shows that even simple examples can significantly enhance performance across domains.

In conclusion, the study explores the mechanisms behind the success of 1-shot RLVR, demonstrating that base models already possess strong reasoning abilities. Experiments show that even a single example can significantly improve performance on reasoning tasks, suggesting the model’s inherent capacity for reasoning. The study highlights that policy gradient loss is key to 1-shot RLVR’s effectiveness, with entropy loss further enhancing performance. Additionally, encouraging exploration through techniques like entropy regularization can improve post-saturation generalization. The findings also emphasize the need for careful data selection to optimize the model’s performance, particularly in data-constrained scenarios. 

Check out the Paper and GitHub Page. Also, don’t forget to follow us on Twitter and join our Telegram Channel and LinkedIn Group. Don’t Forget to join our 90k+ ML SubReddit. For Promotion and Partnerships, please talk us.

[Register Now] miniCON Virtual Conference on AGENTIC AI: FREE REGISTRATION + Certificate of Attendance + 4 Hour Short Event (May 21, 9 am- 1 pm PST) + Hands on Workshop

The post LLMs Can Learn Complex Math from Just One Example: Researchers from University of Washington, Microsoft, and USC Unlock the Power of 1-Shot Reinforcement Learning with Verifiable Reward appeared first on MarkTechPost.

A recent survey by researchers at Shanghai Jiao Tong University and ANP Community offers the first comprehensive taxonomy and evaluation of protocols for AI agents. The work introduces a principled classification scheme, explores existing protocol frameworks, and outlines future directions for scalable, secure, and intelligent agent ecosystems.

The Communication Problem in Modern AI Agents

The deployment of LLM agents has outpaced the development of mechanisms that enable them to interact with each other or with external resources. In practice, most agent interactions rely on ad hoc APIs or brittle function-calling paradigms—approaches that lack generalizability, security guarantees, and cross-vendor compatibility.

The issue is analogous to the early days of the Internet, where the absence of common transport and application-layer protocols prevented seamless information exchange. Just as TCP/IP and HTTP catalyzed global connectivity, standard protocols for AI agents are poised to serve as the backbone of a future “Internet of Agents.”

A Framework for Agent Protocols: Context vs. Collaboration

The authors propose a two-dimensional classification system that delineates agent protocols along two axes:

1. Context-Oriented vs. Inter-Agent Protocols
   • Context-Oriented Protocols govern how agents interact with external data, tools, or APIs.
   • Inter-Agent Protocols enable peer-to-peer communication, task delegation, and coordination across multiple agents.
2. General-Purpose vs. Domain-Specific Protocols
   • General-purpose protocols are designed to operate across diverse environments and agent types.
   • Domain-specific protocols are optimized for particular applications such as human-agent dialogue, robotics, or IoT systems.

This classification helps clarify the design trade-offs across flexibility, performance, and specialization.

Key Protocols and Their Design Principles

1. Model Context Protocol (MCP) – Anthropic

MCP is a general-purpose context-oriented protocol that facilitates structured interaction between LLM agents and external resources. Its architecture decouples reasoning (host agents) from execution (clients and servers), enhancing security and scalability. Notably, MCP mitigates privacy risks by ensuring that sensitive user data is processed locally, rather than embedded directly into LLM-generated function calls.

2. Agent-to-Agent Protocol (A2A) – Google

Designed for secure and asynchronous collaboration, A2A enables agents to exchange tasks and artifacts in enterprise settings. It emphasizes modularity, multimodal support (e.g., files, streams), and opaque execution, preserving IP while enabling interoperability. The protocol defines standardized entities such as Agent Cards, Tasks, and Artifacts for robust workflow orchestration.

3. Agent Network Protocol (ANP) – Open-Source

ANP envisions a decentralized, web-scale agent network. Built atop decentralized identity (DID) and semantic meta-protocol layers, ANP facilitates trustless, encrypted communication between agents across heterogeneous domains. It introduces layered abstractions for discovery, negotiation, and task execution—positioning itself as a foundation for an open “Internet of Agents.”

Performance Metrics: A Holistic Evaluation Framework

To assess protocol robustness, the survey introduces a comprehensive framework based on seven evaluation criteria:

• Efficiency – Throughput, latency, and resource utilization (e.g., token cost in LLMs)
• Scalability – Support for increasing agents, dense communication, and dynamic task allocation
• Security – Fine-grained authentication, access control, and context desensitization
• Reliability – Robust message delivery, flow control, and connection persistence
• Extensibility – Ability to evolve without breaking compatibility
• Operability – Ease of deployment, observability, and platform-agnostic implementation
• Interoperability – Cross-system compatibility across languages, platforms, and vendors

This framework reflects both classical network protocol principles and agent-specific challenges such as semantic coordination and multi-turn workflows.

Toward Emergent Collective Intelligence

One of the most compelling arguments for protocol standardization lies in the potential for collective intelligence. By aligning communication strategies and capabilities, agents can form dynamic coalitions to solve complex tasks—akin to swarm robotics or modular cognitive systems. Protocols such as Agora take this further by enabling agents to negotiate and adapt new protocols in real time, using LLM-generated routines and structured documents.

Similarly, protocols like LOKA embed ethical reasoning and identity management into the communication layer, ensuring that agent ecosystems can evolve responsibly, transparently, and securely.

The Road Ahead: From Static Interfaces to Adaptive Protocols

Looking forward, the authors outline three stages in protocol evolution:

• Short-Term: Transition from rigid function calls to dynamic, evolvable protocols.
• Mid-Term: Shift from rule-based APIs to agent ecosystems capable of self-organization and negotiation.
• Long-Term: Emergence of layered infrastructures that support privacy-preserving, collaborative, and intelligent agent networks.

These trends signal a departure from traditional software design toward a more flexible, agent-native computing paradigm.

Conclusion

The future of AI will not be shaped solely by model architecture or training data—it will be shaped by how agents communicate, coordinate, and learn from one another. Protocols are not merely technical specifications; they are the connective tissue of intelligent systems. By formalizing these communication layers, we unlock the possibility of a decentralized, secure, and interoperable network of agents—an architecture capable of scaling far beyond the capabilities of any single model or framework.

Check out the model on Paper. Also, don’t forget to follow us on Twitter and join our Telegram Channel and LinkedIn Group. Don’t Forget to join our 90k+ ML SubReddit.

[Register Now] miniCON Virtual Conference on AGENTIC AI: FREE REGISTRATION + Certificate of Attendance + 4 Hour Short Event (May 21, 9 am- 1 pm PST) + Hands on Workshop

The post Building the Internet of Agents: A Technical Dive into AI Agent Protocols and Their Role in Scalable Intelligence Systems appeared first on MarkTechPost.

Llama 4: The Engine Behind Meta AI

At the core of the Meta AI app is Llama 4, Meta’s most advanced large language model to date. Llama 4 introduces a mixture-of-experts architecture, enabling the model to handle complex tasks more efficiently. It supports multimodal inputs, allowing users to interact using both text and images, and offers multilingual capabilities across 12 languages. The model comes in two variants: Scout and Maverick. Scout features 17 billion active parameters with a 10 million token context window, while Maverick boasts 400 billion parameters and a 1 million token context window.

Personalized Assistance Through Social Integration

What sets the Meta AI app apart is its deep integration with Meta’s existing social platforms. By leveraging data from Facebook and Instagram, the app can tailor responses based on user preferences and social context. For instance, if a user has shared interests or past interactions on these platforms, Meta AI can provide more relevant and personalized responses.

Users can also instruct Meta AI to remember specific details, such as dietary restrictions or favorite activities, enhancing the personalization of future interactions.

Discover Feed: Socializing AI Interactions

A standout feature of the Meta AI app is the “Discover” feed, which allows users to share their AI interactions with the community. This feed showcases a variety of prompts and responses, enabling users to explore and engage with content generated by others. To populate this feed, Meta enlisted content creators, including meme makers and travel bloggers, to test the app and share their experiences.

While the Discover feed includes interactive elements like likes and comments, it currently lacks full social networking functionalities such as follower systems or search options. Nevertheless, it represents a step toward making AI interactions more communal and engaging.​

Voice Interaction and Cross-Platform Continuity

The Meta AI app emphasizes voice-first interaction, allowing users to engage in conversations using natural language. This feature is particularly beneficial for multitasking and is currently available in the United States, Canada, Australia, and New Zealand.

Moreover, the app integrates seamlessly with Meta’s Ray-Ban smart glasses, replacing the existing Meta View app. This integration enables users to initiate conversations through the glasses and continue them on their phones or desktops, ensuring a cohesive experience across devices.

Conclusion

Meta’s launch of its standalone AI app marks a pivotal moment in the evolution of digital assistants. By combining advanced language modeling with deep social integration, the Meta AI app offers a personalized and engaging user experience. As the company continues to refine and expand the app’s capabilities, it positions itself as a formidable competitor in the AI assistant landscape.

Check out the Technical details and Download the app here. Also, don’t forget to follow us on Twitter and join our Telegram Channel and LinkedIn Group. Don’t Forget to join our 90k+ ML SubReddit.

[Register Now] miniCON Virtual Conference on AGENTIC AI: FREE REGISTRATION + Certificate of Attendance + 4 Hour Short Event (May 21, 9 am- 1 pm PST) + Hands on Workshop

The post Meta AI Introduces First Version of Its Llama 4-Powered AI App: A Standalone AI Assistant to Rival ChatGPT appeared first on MarkTechPost.

Sparse attention attempts to reduce this computational burden by approximating dense attention using only a subset of key-query pairs. This has the potential to significantly accelerate long-sequence processing and reduce memory requirements, while still preserving model accuracy. However, despite its promise, sparse attention has yet to be thoroughly evaluated at scale. Existing studies have only scratched the surface, often focusing on limited model sizes, restricted sequence lengths, and specific applications such as multi-turn dialogue. Furthermore, the datasets used in these studies usually vary in length, making it difficult to analyze how performance scales with longer sequences. As a result, the practical viability and robustness of sparse attention strategies remain underexplored.

Researchers from the University of Edinburgh, Cohere, and Meta conducted an extensive evaluation of training-free sparse attention methods across various model sizes, sequence lengths, and sparsity levels. Their study involved nine long-context tasks, including new natural language-based benchmarks designed for controlled and realistic testing. Key findings reveal that for long sequences, large, sparse models outperform smaller, dense ones under fixed computational budgets. While higher sparsity is more tolerable during decoding, no single sparse strategy works universally across tasks. They also introduce scaling laws for sparse attention and release standardized implementations to support reproducible research and guide informed deployment decisions.

Sparse attention aims to reduce computational and memory costs in Transformers by selectively computing only important query–key interactions. This helps speed up full-sequence “prefilling” and reduce memory load during “decoding.” Key techniques include selecting which parts of the attention matrix to retain (e.g., blocks, windows), estimating importance using fixed or dynamic patterns, and allocating computational budgets either uniformly or adaptively across layers and heads. For decoding, methods either evict less useful key–value pairs to conserve memory or maintain the full cache and load only the necessary parts, balancing speed, memory efficiency, and information retention during generation.

The study investigates sparse attention methods in long-context models, analyzing performance under fixed computational budgets. At shorter sequence lengths (32k tokens), smaller dense models perform more efficiently, while at longer lengths (128k), larger sparse models are preferable. Compression tolerance varies by model size and task, with larger models maintaining performance even at 20× sparsity. However, some tasks remain sensitive to high compression. No single method consistently excels; chunk-based methods, such as Quest, perform best in decoding, while Vertical-Slash works well in prefilling for simple tasks. A log-linear scaling law effectively predicts accuracy trends across model size, sequence length, and compression ratio.

In conclusion, the study presents a comprehensive evaluation of sparse attention methods across various model sizes (up to 72 billion parameters), sequence lengths (up to 128 kilobytes), and sparsity levels (up to 95%) on diverse long-sequence tasks. It finds that, under fixed compute (isoFLOPS), large sparse models outperform smaller dense ones for long contexts. While high sparsity (10–15×) can retain accuracy, performance drops significantly on some tasks even at moderate compression. The best sparsity strategy varies by task and phase (prefilling versus decoding), highlighting the absence of a universal solution. The authors also propose reliable scaling laws, suggesting sparse attention is promising but requires careful, task-specific application.

Check out the Paper. Also, don’t forget to follow us on Twitter and join our Telegram Channel and LinkedIn Group. Don’t Forget to join our 90k+ ML SubReddit.

[Register Now] miniCON Virtual Conference on AGENTIC AI: FREE REGISTRATION + Certificate of Attendance + 4 Hour Short Event (May 21, 9 am- 1 pm PST) + Hands on Workshop

The post Exploring the Sparse Frontier: How Researchers from Edinburgh, Cohere, and Meta Are Rethinking Attention Mechanisms for Long-Context LLMs appeared first on MarkTechPost.