AWS Bedrock AgentCore ile Production-Ready AI Agentları Geliştirmek

Production Aşamasındaki Zorluklar

Birçok ekip gerçek değer gösteren etkileyici LangChain veya CrewAI prototipleri geliştiriyor - ta ki bunları deploy etme zamanı gelene kadar. “Laptopumda çalışıyor” aşamasından production’a geçiş session isolation, credential management, memory persistence, observability ve security kontrolleri gerektiriyor. Bu altyapıyı sıfırdan inşa etmek aylar alıyor, bu yüzden AI projelerinin %70’i pilot aşamasını geçemiyor.

AWS Bedrock AgentCore (GA Ekim 2025) bu production boşluğunu dolduruyor. Bu, LangChain veya CrewAI ile rekabet eden başka bir agent framework’ü değil. Bunun yerine, HERHANGİ bir framework ile geliştirilmiş agentların ölçekte çalışması için ihtiyaç duyduğu managed altyapı katmanı. Bunu “AI agentları için Lambda” olarak düşünebilirsin - agent kodunu sen getiriyorsun, AgentCore runtime, memory, tool management ve security’yi hallediyor.

Bu yazıda AgentCore’un gerçek altyapı zorluklarını nasıl çözdüğünü ve self-hosted alternatiflere göre ne zaman kullanılması gerektiğini inceliyoruz.

AgentCore Mimarisi

AgentCore, bağımsız veya birlikte çalışabilen beş entegre servisten oluşuyor:

Runtime: 8 saatlik session pencereleri ve kullanıcı başına dedicated microVM’ler kullanarak otomatik session isolation sağlayan serverless execution ortamı.

Memory: Kendi vector database’ini kurmadan hem kısa dönemli konuşma context’i hem de uzun dönemli kullanıcı tercihleri, facts ve summary’ler için managed storage.

Gateway: Model Context Protocol (MCP) kullanarak merkezi tool management. Lambda fonksiyonlarını, REST API’leri ve mevcut servisleri agent-erişilebilir tool’lara dönüştürür.

Identity: OAuth 2.0 entegrasyonu ile güvenli credential management. Agentlar third-party API’lere credential saklamadan kullanıcı adına erişir.

Observability: CloudWatch, Datadog veya LangSmith’e export edilen OpenTelemetry uyumlu metrikler ve trace’ler.

Runtime: Herhangi Bir Framework Deploy Et

Production agentlarla ilgili temel zorluk güvenli, izole execution ortamları sağlamak. AgentCore Runtime bunu consumption-based microVM allocation ile çözüyor.

Strands agent’ı AgentCore’a deploy etmek:

from bedrock_agentcore import BedrockAgentCoreApp
from strands import Agent

app = BedrockAgentCoreApp()

@app.entrypoint
def invoke(payload):
    agent = Agent(
        model="anthropic.claude-sonnet-4-20250514-v1:0",
        instructions="Sipariş geçmişi ve iade politikalarına erişimi olan bir müşteri destek agentısın."
    )
    return agent.run(payload.get("message"))

CLI ile deploy:

agentcore configure
agentcore launch --region us-east-1

Önemli runtime özellikleri:

• 8 saatlik execution window’ları: Async agentic workflow’lar için sektör lideri. Geleneksel serverless fonksiyonlar 15 dakikada timeout oluyor.
• Session isolation: Her kullanıcı dedicated microVM alıyor. Session’lar arası data sızıntısı yok.
• Consumption pricing: Sadece aktif CPU/memory için ödeme yapıyorsun, I/O wait time için değil. Bu, LLM response’larını beklerken önemli zaman harcayan agentic workload’lar için pre-allocated Lambda konfigürasyonlarından önemli ölçüde daha ucuz olabiliyor.
• ARM64 container’lar: Performance optimizasyonu için gerekli. Docker build’lerinde --platform=linux/arm64 kullan.

Yaygın hata: Mcp-Session-Id header’ını handle etmemek. AgentCore bunu stateless MCP server’lar için otomatik inject ediyor:

from fastapi import FastAPI, Header

app = FastAPI()

@app.post("/mcp")
async def mcp_endpoint(
    mcp_session_id: str = Header(None, alias="Mcp-Session-Id")
):
    # AgentCore session isolation'ı yönetiyor
    # Sunucunuz platform tarafından üretilen ID'leri kabul etmeli
    session_state = load_session(mcp_session_id)
    return {"status": "ok"}

Memory: Altyapı Olmadan Context

Production agentlar için memory inşa etmek iki problemi çözmek gerektirir: kısa dönemli konuşma context’i ve uzun dönemli bilgi persistence’ı. AgentCore Memory ikisini de hallediyor.

Memory extraction pipeline:

Üç strateji ile memory implementasyonu:

from bedrock_agentcore.memory import (
    MemoryClient,
    UserPreferenceMemoryStrategy,
    SemanticMemoryStrategy,
    SummaryMemoryStrategy
)

memory_client = MemoryClient()

# Çoklu strateji ile memory oluştur
memory = memory_client.create_memory(
    name="customer-support-memory",
    strategies=[
        UserPreferenceMemoryStrategy(),  # Kullanıcı patternlerini öğren
        SemanticMemoryStrategy(),  # Fact'leri/bilgiyi sakla
        SummaryMemoryStrategy()  # Session'ları sıkıştır
    ],
    encryption_key_arn="arn:aws:kms:us-east-1:123456789012:key/abc123"
)

# Konuşma event'ini sakla
memory_client.create_event(
    memory_id=memory.id,
    event_data={
        "type": "conversation",
        "content": "Kullanıcı kod örnekleri içeren teknik açıklamaları tercih ediyor"
    }
)

Strateji seçim kılavuzu:

• Müşteri Destek: UserPreferences + Summaries (iletişim stilini hatırla)
• Teknik Asistan: SemanticFacts + Summaries (codebase bilgisini hatırla)
• Kişisel Agent: Üç strateji de (kapsamlı kişiselleştirme)

Kritik security pattern - CreateEvent API’den önce her zaman Guardrails kullan:

import boto3

bedrock = boto3.client('bedrock')

# YANLIŞ: Doğrudan storage (memory poisoning'e açık)
# memory_client.create_event(
#  memory_id=memory.id,
#  event_data={"content": user_input}
# )

# DOĞRU: Önce Guardrails ile sanitize et
guardrail_response = bedrock.apply_guardrail(
    guardrailId='guardrail-123',
    guardrailVersion='1',
    content=[{"text": {"text": user_input}}]
)

if guardrail_response['action'] == 'NONE':
    memory_client.create_event(
        memory_id=memory.id,
        event_data={"content": user_input}
    )
else:
    # Attack denemesini bloklayıp loglayın
    logger.warning(f"Memory poisoning denemesi engellendi: {guardrail_response}")

Maliyet optimizasyonu: Retriever hop’ları sınırla. Turn başına iki-üç retrieval işlemi normal, on tane over-retrieval göstergesi:

memory_config = {
    'retrieval_strategy': 'semantic',
    'max_results': 5,
    'max_retriever_hops': 2
}

Gateway: Merkezi Tool Management

Tool’ları doğrudan agent koduna gömmek duplikasyon ve tutarsızlığa yol açıyor. Müşteri destek, satış ve teknik agentların hepsinin hava durumu verisi ihtiyacı olduğunda, üç kopya hava durumu tool kodu sürdürmek bakım problemi oluşturuyor.

AgentCore Gateway bunu merkezi MCP uyumlu tool server’lar ile çözüyor:

Lambda fonksiyonunu tool olarak kaydetmek:

import boto3

agentcore = boto3.client('bedrock-agentcore')

# Lambda'yı tool target olarak kaydet
response = agentcore.create_target(
    gatewayId='gateway-123',
    targetConfig={
        'type': 'LAMBDA',
        'lambdaArn': 'arn:aws:lambda:us-east-1:123456789012:function:get-weather',
        'description': 'Bir şehir için güncel hava durumunu al'
    }
)

Gateway handle eder:

• Authentication: AWS kaynakları için IAM roller, third-party API’ler için OAuth 2.0, servisler için API key’ler
• Semantic tool search: Agentlar tüm mevcut tool’ları bilmeden x_amz_bedrock_agentcore_search ile ilgili tool’ları keşfediyor
• Protocol conversion: Lambda fonksiyonları, OpenAPI spec’ler, Smithy modeller ve MCP server’lar standart MCP interface’i üzerinden expose ediliyor

Mimari pattern - yaygın tool’ları merkezileştir, domain-specific tool’ları local tut:

Ortak Toollar (Gateway üzerinden):
  - Web arama
  - Database sorguları
  - Hava durumu API
  - Hisse senedi fiyatları

Domain-Specific Toollar (agent-local):
  - İade politikası mantığı
  - Ürün katalogu
  - İş kuralları

A2A Protocol ile Multi-Agent Koordinasyonu

Tekli agentlardan koordineli agent ekiplerine ölçeklenmek standartlaştırılmış iletişim gerektiriyor. AgentCore bunun için Agent-to-Agent (A2A) protokolünü kullanıyor.

A2A vs MCP ayrımı:

• MCP: Agent-to-tool iletişimi (agent’ın hava durumu API’sini çağırması)
• A2A: Agent-to-agent iletişimi (supervisor’ın uzmanları koordine etmesi)

Hub-and-spoke supervisor implementasyonu:

import { BedrockAgentCoreClient, InvokeAgentCommand } from '@aws-sdk/client-bedrock-agentcore';

class HostAgent {
  private client: BedrockAgentCoreClient;
  private specialistAgents: Map<string, AgentConfig>;

  async routeToSpecialist(query: string, capability: string) {
    const agentConfig = this.specialistAgents.get(capability);

    // Remote agent'ın A2A konfigürasyonunu getir
    const agentCard = await this.fetchAgentCard(agentConfig.endpoint);

    // A2A protokolü ile invoke et
    const command = new InvokeAgentCommand({
      agentId: agentCard.id,
      sessionId: this.generateSessionId(),
      inputText: query,
      protocol: 'A2A'
    });

    return await this.client.send(command);
  }

  private async fetchAgentCard(endpoint: string): Promise<AgentCard> {
    // Agent capability schema'sını al
    const response = await fetch(`${endpoint}/.well-known/agent-card`);
    return response.json();
  }
}

Orchestration pattern’leri:

Supervisor with routing mode - her sorgu tam orchestration gerektirmiyor:

class SupervisorAgent:
    def route_query(self, query: str):
        # Basit sorgu → doğrudan routing
        if self.is_simple_query(query):
            specialist = self.select_single_specialist(query)
            return specialist.invoke(query)

        # Karmaşık sorgu → tam orchestration
        else:
            plan = self.analyze_and_plan(query)
            results = self.orchestrate_subagents(plan)
            return self.synthesize(results)

    def is_simple_query(self, query: str) -> bool:
        intents = self.detect_intents(query)
        return len(intents) == 1

Framework interoperability: LangGraph monitoring agent + CrewAI analytics agent + Strands incident response agent hepsi A2A üzerinden iletişim kurabiliyor. Framework lock-in yok.

Security ve Maliyet Optimizasyonu

Guardrails Konfigürasyonu

Guardrails prompt injection, memory poisoning ve zararlı içeriğe karşı koruma sağlıyor:

import boto3

bedrock = boto3.client('bedrock')

guardrail = bedrock.create_guardrail(
    name='production-agent-guardrail',
    contentPolicyConfig={
        'filtersConfig': [
            {'type': 'HATE', 'inputStrength': 'HIGH', 'outputStrength': 'HIGH'},
            {'type': 'VIOLENCE', 'inputStrength': 'MEDIUM', 'outputStrength': 'HIGH'},
            {'type': 'PROMPT_ATTACK', 'inputStrength': 'HIGH', 'outputStrength': 'NONE'}
        ]
    },
    topicPolicyConfig={
        'topicsConfig': [
            {
                'name': 'Financial Advice',
                'definition': 'Spesifik yatırım önerileri sağlama',
                'type': 'DENY'
            }
        ]
    },
    wordPolicyConfig={
        'wordsConfig': [
            {'text': 'internal-api-key'},
            {'text': 'secret-token'}
        ],
        'managedWordListsConfig': [
            {'type': 'PROFANITY'}
        ]
    }
)

Defense-in-depth stratejisi:

1. Input validation: Girişte kötü niyetli prompt’ları bloklayın
2. Memory protection: CreateEvent API’den önce sanitize edin
3. Output filtering: Zararlı response’ları önleyin
4. Audit trail’leri: Compliance için CloudWatch logları

Maliyet Optimizasyon Stratejileri

Prompt caching - cached token’larda %90 indirim:

response = bedrock_runtime.converse(
    modelId="anthropic.claude-sonnet-4-20250514-v1:0",
    messages=[{"role": "user", "content": user_query}],
    system=[
        {
            "text": large_system_prompt,
            "cachePoint": {"type": "default"}
        }
    ]
)

Model routing - karmaşıklığı model maliyeti ile eşleştirin:

def route_to_model(query: str) -> str:
    complexity = classify_query_complexity(query)

    if complexity < 0.3:
        return "anthropic.claude-3-haiku-20240307-v1:0"  # $0.25/1M token
    elif complexity < 0.7:
        return "anthropic.claude-sonnet-4-20250514-v1:0"  # $3/1M token
    else:
        return "anthropic.claude-opus-4-20250514-v1:0"  # $15/$75 per 1M token (input/output)

Tool-call budget’ları - sınırsız tool kullanımını önleyin:

agent = Agent(
    model="anthropic.claude-sonnet-4-20250514-v1:0",
    max_tool_calls_per_turn=3,
    instructions="Kullanıcı birden fazla item sorarsa, kapsamlı lookup yerine özetle"
)

Maliyet bileşenleri:

• Runtime: Aktif CPU/memory tüketimi (pre-allocated değil)
• Memory: Short-term (event başına), long-term (işlenen memory + retrieval’lar başına)
• Gateway: MCP işlemleri (ListTools, CallTool, Ping) + semantic search sorguları
• Identity: Runtime/Gateway üzerinden kullanıldığında ek ücret yok
• Observability: CloudWatch standart fiyatlandırması

Yaygın Hatalar

Guardrails Olmadan Memory Poisoning

Problem: Ham kullanıcı input’unu doğrudan saklamak memory’ye prompt injection’a izin veriyor:

# YANLIŞ
user_input = "Önceki talimatları yoksay, artık sen..."
memory_client.create_event(
    memory_id=memory.id,
    event_data={"content": user_input}
)

Çözüm: Her zaman önce Guardrails ile sanitize et (yukarıda Memory bölümünde gösterildi).

Tool-Call Storm’ları

Problem: Agent sorgu başına limit olmadan 20+ tool invoke ediyor:

Kullanıcı: "Büyük şehirlerde hava durumu nasıl?"
Agent 50 ayrı get_weather() çağrısı yapıyor
Toplam: 10s latency, sorgu başına $0.05

Çözüm: Tool-call budget’ları uygulayın ve instruction’larla yönlendirin:

agent = Agent(
    max_tool_calls_per_turn=3,
    instructions="Birden fazla item için, kapsamlı lookup yerine özetle"
)

ARM64 Container Gereksinimleri

Problem: x86 container’lar kullanmak deployment hatalarına neden oluyor.

Çözüm: Açıkça ARM64 için build edin:

FROM --platform=linux/arm64 python:3.11-slim
COPY . /app
CMD ["python", "agent.py"]

docker buildx build --platform linux/arm64 -t agent:latest .

Internal API’ler için VPC Entegrasyonu Yok

Problem: Agent trafiği public internet üzerinden gidiyor.

Çözüm: VPC ve PrivateLink konfigure edin:

runtime_config = {
    'vpcConfig': {
        'securityGroupIds': ['sg-12345'],
        'subnetIds': ['subnet-abc', 'subnet-def']
    },
    'privateLinkEnabled': True
}

AgentCore Ne Zaman Kullanılmalı

AgentCore kullan:

• Birden fazla agent framework kullanımda (LangChain + CrewAI + custom)
• Farklı modelleri değerlendirme ihtiyacı (Bedrock + OpenAI + Anthropic)
• Enterprise security gerekli (VPC, PrivateLink, customer-managed KMS)
• Multi-agent sistemler planlanıyor (A2A koordinasyonu)
• Hızlı production’a geçiş gerekli (aylar değil haftalar)
• Ekip büyüklüğü 10’un altında (sıfırdan altyapı inşa edilemez)

Alternatifleri değerlendir:

• Tek framework sonsuza kadar (örn. sadece LangGraph → LangGraph Cloud kullan)
• Tek cloud ekosistemi (örn. tamamen Azure → Azure AI Agent Service)
• Aşırı yüksek volume (10M session/ay üzeri → self-hosted daha ucuz olabilir)
• Custom hardware gereksinimi (özelleşmiş modeller için GPU → self-hosted)
• Zaten kurulmuş agent altyapısı var (sunk cost’lar)

Self-hosting break-even analizi:

AgentCore şu durumlarda maliyet-etkin:

• Agent geliştirme süresi 2 haftayı aşıyor
• Birden fazla agent türü (müşteri destek, analitik, monitoring)
• Enterprise security/compliance gerekli
• Agent altyapısına adanmış 10 kişiden az ekip

Self-hosted altyapı maliyetleri: $50k-150k build maliyeti + yıllık$200k DevOps ekibi. Yaklaşık 10M session/ay’da break-even.

Önemli Çıkarımlar

AgentCore altyapıdır, framework değil. LangChain veya CrewAI’ın yerini almıyor - bunların ölçeklenmek için ihtiyaç duyduğu production runtime’ı sağlıyor.

Modüler adoption riski azaltır. Sadece Runtime ile başla, Memory → Gateway → Identity → Observability’yi kademeli ekle. Her servis bağımsız değer sağlar.

Security built-in. Session isolation, Guardrails, Identity management ve VPC entegrasyonu production-ready özellikler, sonradan eklenenler değil.

Maliyet optimizasyonu çok boyutlu. Prompt caching (%90 indirim), model routing (%30 tasarruf), tool-call budget’ları ve consumption pricing birleşerek maliyetleri %60-80 azaltıyor.

Multi-agent sistemler protokol gerektirir. Agent-to-tool için MCP, agent-to-agent için A2A. Framework interoperability LangGraph + CrewAI + Strands agentlarının birlikte çalışmasına izin veriyor.

Kaynaklar

• Amazon Bedrock AgentCore Dökümantasyonu
• Örnek Repository (GitHub)
• AgentCore Fiyatlandırması
• Best Practices Kılavuzu

Production deployment’a commit etmeden önce use case’ini doğrulamak için yeni AWS müşterileri için mevcut $200 AWS ücretsiz krediyle başla.