What problem do stateful MCP client capabilities solve on Amazon Bedrock AgentCore Runtime?

Stateful Model Context Protocol (MCP) client capabilities on Amazon Bedrock AgentCore Runtime address the critical limitations of previous stateless AI agent implementations. Stateless agents struggled with interactive, multi-turn workflows, as they couldn't pause mid-execution to solicit user input for clarification, request dynamic large language model (LLM)-generated content, or provide real-time progress updates during lengthy operations. Each request was independent, lacking shared context. This new feature fundamentally transforms agent interactions by enabling bidirectional conversations, allowing agents to maintain conversational threads, gather necessary input precisely when needed, generate dynamic content on the fly, and transparently inform users about ongoing processes. This leads to the development of significantly more responsive, intelligent, and user-centric AI applications capable of complex, adaptive workflows.

How does the transition from stateless to stateful mode work on AgentCore Runtime?

The transition to stateful mode within Amazon Bedrock AgentCore Runtime is initiated by a simple configuration adjustment: setting `stateless_http=False` when starting your MCP server. Once enabled, AgentCore Runtime provisions a dedicated microVM for each individual user session. This microVM is designed for persistence throughout the session's duration, which can last up to 8 hours or expire after 15 minutes of inactivity, ensuring isolated CPU, memory, and filesystem resources for each session. Continuity across interactions is maintained through a unique `Mcp-Session-Id` header. This ID is established during the initial handshake and subsequently included by the client in all follow-up requests, ensuring they are accurately routed back to the correct, persistent session, thereby preserving context and enabling complex, interactive dialogues.

What is Elicitation, and how does it enhance AI agent interactions?

Elicitation is a powerful stateful MCP capability that allows an AI agent (acting as the MCP server) to intelligently pause its ongoing execution and request specific, structured input directly from the user via the client. This significantly enhances interactive agent workflows by enabling agents to ask targeted questions at precise, opportune moments within their operational flow. For example, an agent might use elicitation to confirm a decision, gather user preferences, or collect particular data values that are contingent on preceding steps. The feature supports two robust modes: 'Form mode' for direct structured data collection through the MCP client, and 'URL mode' for secure, out-of-band interactions that require directing the user to an external URL (e.g., for OAuth or sensitive credential entry). The user's response – whether accepting, declining, or canceling the request – is then returned to the server, allowing the agent to dynamically adapt its workflow based on real-time human feedback.

How does Sampling capability benefit AI agents without managing LLM credentials?

Sampling equips the MCP server with the ability to request sophisticated large language model (LLM)-generated content directly from the client using the `sampling/createMessage` mechanism. A key benefit is that the MCP server itself does not need to manage its own LLM credentials, API keys, or direct integrations with various LLM providers. Instead, the server simply provides a well-formed prompt and any optional model preferences to the client. The client then acts as an intelligent intermediary, forwarding this request to its connected LLM and returning the generated response back to the server. This abstraction allows AI agents to seamlessly leverage powerful language model capabilities for tasks such as crafting personalized summaries, generating natural-language explanations from complex structured data, or producing context-aware recommendations, all while simplifying the operational overhead and security concerns associated with LLM management on the server side.

Amazon Bedrock: Tillståndsberoende MCP-klientfunktioner i AgentCore Runtime

Förbättra AI-agenter: Övergången till tillståndsberoende MCP på Amazon Bedrock

AI-agenter utvecklas snabbt, men deras fulla potential har ofta hindrats av tillståndslösa implementeringar, särskilt i scenarier som kräver realtidsinteraktion med användare, dynamisk innehållsgenerering eller pågående framstegsuppdateringar. Utvecklare som bygger sofistikerade AI-agenter står ofta inför utmaningar när arbetsflöden behöver pausas, samla in förtydliganden eller rapportera status under långvariga operationer. Den stela, enkelriktade karaktären hos tillståndslös exekvering begränsar utvecklingen av verkligt interaktiva och responsiva AI-applikationer.

Nu introducerar Amazon Bedrock AgentCore Runtime banbrytande tillståndsberoende (stateful) klientfunktioner för Model Context Protocol (MCP), som förändrar hur AI-agenter interagerar med användare och stora språkmodeller (LLM). Denna avgörande uppdatering befriar agenter från begränsningarna i tillståndslös kommunikation, vilket möjliggör komplexa, flerstegs- och mycket interaktiva arbetsflöden. Genom att integrera avgörande MCP-klientfunktioner – Framkallning (Elicitation), Sampling och Framstegsmeddelanden (Progress Notifications) – underlättar Bedrock AgentCore Runtime dubbelriktade konversationer mellan MCP-servrar och klienter, vilket banar väg för mer intelligenta och användarcentrerade AI-lösningar.

Från tillståndslöst till tillståndsberoende: Låser upp interaktiva agentarbetsflöden

Tidigare fungerade MCP-serverstödet på AgentCore i ett tillståndslöst läge, där varje HTTP-förfrågan fungerade oberoende, utan något delat sammanhang. Även om detta förenklade implementeringen för enkla verktygsservrar, begränsade det allvarligt scenarier som krävde konversationskontinuitet, användarklarifiering mitt i arbetsflödet eller framstegsrapportering i realtid. Servern kunde helt enkelt inte upprätthålla en konversationstråd över diskreta förfrågningar, vilket hindrade utvecklingen av verkligt interaktiva agenter.

Införandet av tillståndsberoende MCP-klientfunktioner förändrar detta paradigm i grunden. Genom att ställa in stateless_http=False under serverstart provisionerar AgentCore Runtime en dedikerad mikro-VM för varje användarsession. Denna mikro-VM består under sessionens varaktighet – upp till 8 timmar, eller 15 minuters inaktivitet per idleRuntimeSessionTimeout-inställning – vilket säkerställer isolering av CPU, minne och filsystem mellan sessionerna. Kontinuitet upprätthålls genom ett Mcp-Session-Id-huvud, som servern tillhandahåller under initieringen och klienten inkluderar i alla efterföljande förfrågningar för att dirigera tillbaka till samma session. Denna dedikerade, beständiga miljö gör att agenter kan komma ihåg sammanhang, begära användarinmatning, generera dynamiskt LLM-innehåll och tillhandahålla kontinuerliga uppdateringar.

Följande tabell sammanfattar de viktigaste skillnaderna mellan tillståndslösa och tillståndsberoende lägen:

	Tillståndslöst läge	Tillståndsberoende läge
`stateless_http`-inställning	`TRUE`	`FALSE`
Sessionsisolering	Dedikerad mikro-VM per session	Dedikerad mikro-VM per session
Sessionens livslängd	Upp till 8 timmar; 15 minuters inaktivitets-timeout	Upp till 8 timmar; 15 minuters inaktivitets-timeout
Klientfunktioner	Stöds ej	Framkallning, sampling, framstegsmeddelanden
Rekommenderas för	Enkel verktygsservering	Interaktiva, flerstegsarbetsflöden

När en session upphör eller servern startas om, kommer efterföljande förfrågningar med det gamla sessions-ID:t att returnera en 404. Vid den tidpunkten måste klienter återinitiera anslutningen för att få ett nytt sessions-ID och starta en ny session. Konfigurationsändringen för att aktivera tillståndsberoende läge är en enda flagga i din serverstart:

mcp.run( transport="streamable-http", host="0.0.0.0", port=8000, stateless_http=False # Aktivera tillståndsberoende läge)

Utöver denna flagga blir de tre klientfunktionerna automatiskt tillgängliga när MCP-klienten deklarerar stöd för dem under initieringshandskakningen.

Fördjupning i nya klientfunktioner: Framkallning, Sampling och Framsteg

Med övergången till tillståndsberoende läge låser Amazon Bedrock AgentCore Runtime upp tre kraftfulla klientfunktioner från MCP-specifikationen, var och en utformad för att hantera distinkta interaktionsmönster som är avgörande för avancerade AI-agenter. Dessa funktioner förvandlar det som en gång var en stel, enkelriktad kommandoexekvering till en flytande, dubbelriktad dialog mellan en MCP-server och dess anslutna klienter. Det är viktigt att notera att dessa funktioner är valbara, vilket innebär att klienter deklarerar sitt stöd under initiering, och servrar får endast använda funktioner som den anslutna klienten har annonserat.

Framkallning: Möjliggör dynamisk användarinmatning i AI-agenter

Framkallning (Elicitation) står som en hörnsten i interaktiv AI, vilket gör det möjligt för en MCP-server att klokt pausa sin exekvering och begära specifik, strukturerad input från användaren via klienten. Denna förmåga ger verktyget möjlighet att ställa precisa frågor vid lämpliga tidpunkter inom sitt arbetsflöde, oavsett om det handlar om att bekräfta ett beslut, samla in en användarpreferens eller samla in ett värde som härrör från föregående operationer. Servern initierar detta genom att skicka en elicitation/create JSON-RPC-förfrågan, som inkluderar ett läsbart meddelande och ett valfritt requestedSchema som beskriver den förväntade svarsstrukturen.

MCP-specifikationen tillhandahåller två robusta lägen för framkallning:

Formläge: Detta är idealiskt för att samla in strukturerad data direkt via MCP-klienten, såsom konfigurationsparametrar, användarpreferenser eller enkla bekräftelser där känslig data inte är inblandad.
URL-läge: För interaktioner som kräver en säker, extern process, såsom OAuth-flöden, betalningshantering eller inmatning av känsliga uppgifter, dirigerar URL-läget användaren till en extern URL. Detta säkerställer att känslig information helt och hållet kringgår MCP-klienten, vilket förbättrar säkerheten och efterlevnaden.

Vid mottagandet av en framkallningsförfrågan renderar klienten ett lämpligt inmatningsgränssnitt. Användarens efterföljande åtgärd utlöser en tre-åtgärds svarsmodell tillbaka till servern: accept (användaren tillhandahöll den begärda informationen), decline (användaren avvisade uttryckligen förfrågan) eller cancel (användaren avfärdade prompten utan att göra ett val). Intelligenta servrar är utformade för att hantera vart och ett av dessa scenarier på ett robust sätt, vilket säkerställer en stabil och användarvänlig upplevelse. Till exempel kan ett add_expense_interactive-verktyg, som demonstrerats i källmaterialet, vägleda en användare genom en serie frågor – belopp, beskrivning, kategori och slutlig bekräftelse – innan data lagras i ett bakomliggande system som Amazon DynamoDB. Varje steg använder Pydantic-modeller för att definiera den förväntade input, som FastMCP sömlöst konverterar till det JSON Schema som krävs för elicitation/create-förfrågan.

Sampling och Framstegsmeddelanden: Förbättrar LLM-interaktion och transparens

Utöver direkt användarinteraktion utrustar Sampling MCP-servern med förmågan att begära LLM-genererat innehåll direkt från klienten via sampling/createMessage. Detta är en kritisk mekanism eftersom den gör det möjligt för verktygslogik på servern att utnyttja kraftfulla språkmodellsfunktioner utan att behöva hantera sina egna LLM-uppgifter eller direkta API-integrationer. Servern tillhandahåller helt enkelt en prompt och valfria modellpreferenser, och klienten, som agerar som en förmedlare, vidarebefordrar begäran till sin anslutna LLM och returnerar det genererade svaret. Detta öppnar upp för en myriad av praktiska tillämpningar, inklusive att skapa personliga sammanfattningar, generera naturliga språkliga förklaringar från strukturerad data, eller producera sammanhangsmedvetna rekommendationer baserade på den pågående konversationen.

För operationer som sträcker sig över tid blir Framstegsmeddelanden (Progress Notifications) ovärderliga. Denna funktion gör det möjligt för en MCP-server att rapportera inkrementella uppdateringar under långvariga uppgifter. Genom att använda ctx.report_progress(progress, total) kan servern sända ut kontinuerliga uppdateringar som klienter kan översätta till visuell feedback, såsom en förloppsindikator eller en statusindikator. Oavsett om det handlar om att söka genom stora datakällor eller utföra komplexa beräkningsuppgifter, säkerställer transparenta framstegsuppdateringar att användarna förblir informerade, vilket förhindrar frustration och förbättrar den övergripande användarupplevelsen, snarare än att låta dem stirra på en tom skärm och undra om systemet fortfarande är aktivt.

Framtidssäkra AI-agentutveckling med Bedrock AgentCore Runtime

Införandet av tillståndsberoende MCP-klientfunktioner på Amazon Bedrock AgentCore Runtime representerar ett betydande steg framåt i utvecklingen av AI-agenter. Genom att omvandla tidigare tillståndslösa interaktioner till dynamiska, dubbelriktade konversationer, ger AWS utvecklare möjlighet att bygga mer intelligenta, responsiva och användarvänliga AI-applikationer. Dessa funktioner – Framkallning för guidad användarinmatning, Sampling för on-demand LLM-generering och Framstegsmeddelanden för transparens i realtid – låser kollektivt upp en ny era av interaktiva agentarbetsflöden. Allt eftersom AI fortsätter att utvecklas, kommer dessa grundläggande funktioner att vara avgörande för att skapa sofistikerad operationalisering av agent-AI som sömlöst kan integreras i komplexa affärsprocesser, anpassa sig till användarnas behov och leverera exceptionellt värde.