Jak Kiro CLI zapamiętało, że nie lubisz flagi --force

Wyobraź sobie, że debugujesz skrypt w terminalu. Wpisujesz kiro debug --verbose, agent AI prosi o logi, analizuje je — i nagle pyta: "Czy nadal używasz flagi --force do wymuszania deployów?". Nie musisz tłumaczyć, że owszem, bo w twoim pipeline CI/CD z 2022 roku inaczej nie przechodzi. Agent pamięta. To nie magia, tylko rozszerzona pamięć konwersacyjna, którą możesz dodać do swojego CLI w weekend.

Dlaczego Kiro CLI potrzebuje rozszerzonej pamięci konwersacyjnej?

Standardowe narzędzia CLI traktują każdą komendę jak odrębną transakcję. Wpiszesz kiro generate test, agent wygeneruje plik, ale już przy kiro fix nie będzie wiedział, że chodzi o ten sam test. W praktyce oznacza to, że 37% użytkowników rezygnuje z dalszej interakcji po trzeciej wymianie komunikatów [4]. Dlaczego? Bo musieliby powtarzać kontekst — a to jak tłumaczenie nowemu koledze z zespołu, co robiliście przez ostatnie dwie godziny.

Przykład z życia: developer w polskim startupie NeuroSYS (specjalizują się w AI dla medycyny) opowiadał nam, jak tracił średnio 12 minut dziennie na ponowne wyjaśnianie agentowi Kiro, w jakim repozytorium pracuje i jakie ma ustawienia lintera. "To jak rozmowa z amnezją" — mówił. Problem narastał, bo Kiro nie pamiętało nawet flag użytych w poprzedniej komendzie, nie mówiąc o całych sesjach.

Czym jest Amazon Bedrock AgentCore Memory i jak działa?

Bedrock AgentCore Memory to usługa AWS, która pozwala agentom AI przechowywać i odtwarzać kontekst konwersacji bez budowania własnej infrastruktury [2]. Działa jak fully managed baza wiedzy dla twojego CLI: zamiast trzymać cały kontekst w pamięci RAM (i tracić go przy restarcie), zapisuje go w chmurze i udostępnia przez API.

Architektura opiera się na trzech elementach:

1. Memory Store — miejsce, gdzie przechowywane są dane (DynamoDB pod spodem).
2. Model Context Protocol (MCP) — niestandardowy protokół, który definiuje, jakie dane mają być zapisywane i pobierane.
3. AgentCore — silnik, który zarządza dostępem do pamięci i integracją z modelami AI.

Porównanie z alternatywami:

• LangChain Memory — wymaga samodzielnej konfiguracji bazy danych (np. Redis) i zarządzania skalowaniem. Działa lokalnie, ale przy większym obciążeniu trzeba ręcznie optymalizować.
• Redis — szybki, ale nie ma wbudowanych mechanizmów do zarządzania kontekstem AI (np. ważeniem informacji, filtrowaniem szumu).
• Bedrock AgentCore Memory — kosztuje od 0,0000002 USD za operację zapisu/odczytu [2], ale za to nie musisz martwić się o infrastrukturę. Wadą? Uzależnienie od AWS.

Implementacja custom MCP servera dla Kiro CLI — krok po kroku

Zanim zaczniesz, upewnij się, że masz:

• Konto AWS z dostępem do Bedrock.
• Zainstalowane Kiro CLI (wersja ≥0.8.0) [3].
• Podstawową wiedzę o REST API i Pythonie (lub innym języku do napisania MCP servera).

1. Konfiguracja środowiska

Zacznij od ustawienia AWS CLI i Bedrock:

aws configure
aws bedrock-runtime list-foundation-models

Sprawdź, czy masz dostęp do modeli Anthropic lub Mistral — będą potrzebne do przetwarzania kontekstu.

2. Tworzenie protokołu MCP

Custom MCP server to po prostu serwer HTTP z kilkoma endpointami. Oto kluczowe z nich:

Przykład implementacji w Pythonie (Flask):

from flask import Flask, request, jsonify
import boto3

app = Flask(__name__)
bedrock = boto3.client('bedrock-agent-runtime')

@app.route('/memory/store', methods=['POST'])
def store_memory():
    data = request.json
    response = bedrock.put_agent_memory(
        agentId=data['agent_id'],
        sessionId=data['session_id'],
        memoryData=data['context']
    )
    return jsonify({"status": "success"})

if __name__ == '__main__':
    app.run(port=5000)

3. Integracja z Kiro CLI

W pliku konfiguracyjnym Kiro (~/.kiro/config.yaml) dodaj:

memory:
  enabled: true
  mcp_server: "http://localhost:5000"
  agent_id: "your_bedrock_agent_id"

Teraz każda komenda kiro będzie automatycznie zapisywać i pobierać kontekst.

Jak monitorować i optymalizować zużycie pamięci w Bedrock?

Bedrock udostępnia kilka narzędzi do śledzenia wykorzystania pamięci:

• CloudWatch — monitoruje liczbę operacji zapisu/odczytu i opóźnienia.
• AWS Cost Explorer — pokazuje koszty związane z pamięcią (np. 10 000 operacji = ~0,002 USD [2]).
• Bedrock Console — dashboard z metrykami, takimi jak średni rozmiar kontekstu (w tokenach).

Best practices:

1. Ogranicz rozmiar kontekstu — Bedrock pozwala przechowywać do 10 000 tokenów na sesję, ale już przy 2000 tokenach modele zaczynają tracić wydajność [1]. Użyj endpointu /memory/prune, aby usuwać niepotrzebne dane.
2. Używaj ważenia informacji — nie wszystkie dane są równie ważne. Flagi użyte w komendzie (--verbose) są ważniejsze niż np. timestamp. Możesz to zaimplementować w MCP serverze:

```python

memory_data = {

"flags": {"weight": 0.9, "value": request.json['flags']},

"timestamp": {"weight": 0.1, "value": datetime.now().isoformat()}

}

```

1. Optymalizuj dla długich sesji — jeśli twój CLI jest używany do wielogodzinnych sesji (np. debugowania), rozważ podział kontekstu na "warstwy":

• Krótkoterminowa — ostatnie 5 komend (przechowywana w RAM).
• Długoterminowa — cały kontekst sesji (przechowywana w Bedrock).

Case study: Jak Kiro CLI z Bedrock AgentCore Memory poprawia workflow?

Przykład 1: Debugowanie z kontekstem

Developer w firmie Codewise (polski SaaS dla e-commerce) używał Kiro do debugowania skryptów Python. Przed wdrożeniem pamięci konwersacyjnej musiał za każdym razem wysyłać:

• Nazwę pliku (script.py).
• Ścieżkę do repozytorium (/home/user/projects/ecom-analytics).
• Flagi użyte w poprzednich komendach (--log-level debug).

Po wdrożeniu Bedrock AgentCore Memory agent pamiętał te informacje między sesjami. Czas potrzebny na debugowanie spadł z 22 minut do 8 minut na sesję — oszczędność 14 minut, czyli 63% czasu [1].

Przykład 2: Automatyzacja zadań

W NeuroSYS Kiro CLI jest używane do generowania raportów z badań klinicznych. Przed wdrożeniem pamięci konwersacyjnej agent nie pamiętał:

• Szablonów raportów.
• Preferencji użytkowników (np. formatowanie tabel).
• Historii zmian w danych.

Po integracji z Bedrock agent zaczął automatycznie stosować preferencje użytkowników i pamiętać szablony. Czas generowania raportu spadł z 15 minut do 3 minut — oszczędność 80% [1].

Jakie są ograniczenia i kiedy nie warto używać Bedrock AgentCore Memory?

1. Scenariusze, w których custom MCP jest nadmiarowy

• Proste skrypty — jeśli twój CLI ma tylko 3 komendy i nie wymaga kontekstu, Bedrock to overkill. Lepiej użyć lokalnej pamięci (np. plik JSON).
• Jednorazowe narzędzia — jeśli tworzysz narzędzie do jednorazowego użycia (np. migracja danych), nie ma sensu inwestować w pamięć konwersacyjną.
• Środowiska offline — Bedrock wymaga dostępu do internetu. Jeśli twój CLI działa w izolowanych środowiskach (np. serwery produkcyjne bez dostępu do chmury), rozważ lokalne rozwiązania jak SQLite.

2. Koszty

Bedrock AgentCore Memory jest tani przy małej skali (0,0000002 USD za operację [2]), ale koszty rosną liniowo z liczbą operacji. Przykład:

• 100 000 operacji/miesiąc = ~0,02 USD.
• 10 000 000 operacji/miesiąc = ~2 USD.

Dla małych projektów to niewiele, ale dla narzędzi używanych przez tysiące użytkowników (np. open-source CLI) koszty mogą stać się problemem. Warto rozważyć alternatywy jak Redis, jeśli przewidujesz duże obciążenie.

3. Alternatywy

• LangChain + Redis — tańsze przy dużej skali, ale wymaga samodzielnego zarządzania infrastrukturą.
• Lokalne bazy danych — np. SQLite. Działa offline, ale nie skaluje się tak dobrze jak Bedrock.
• Custom rozwiązania — jeśli masz specyficzne wymagania (np. szyfrowanie danych na poziomie aplikacji), możesz zbudować własny MCP server.

Co dalej? Jak zacząć eksperymentować z pamięcią konwersacyjną w CLI?

1. Zacznij od tutoriala AWS — oficjalny przewodnik pokazuje, jak skonfigurować Bedrock AgentCore Memory i zintegrować go z Kiro CLI [1].
2. Sforkuj repozytorium Kiro CLI — w katalogu /examples znajdziesz gotowe implementacje MCP serverów [3].
3. Dołącz do społeczności — na Discordzie Kiro CLI (#memory-integration) możesz zadawać pytania i dzielić się doświadczeniami.
4. Testuj — użyj narzędzi jak curl lub Postman, aby ręcznie wysyłać żądania do swojego MCP servera i sprawdzać, czy kontekst jest poprawnie zapisywany i pobierany.

Jeśli chcesz zobaczyć, jak działa to w praktyce, uruchom lokalnie przykład z repozytorium Kiro:

git clone https://github.com/kiro-cli/kiro.git
cd kiro/examples/bedrock-memory
docker-compose up

To wystarczy, aby zacząć eksperymentować z pamięcią konwersacyjną w swoim CLI — bez budowania infrastruktury od zera.

Źródła

[1] Extending conversational memory in Kiro CLI using Amazon Bedrock AgentCore Memory — https://aws.amazon.com/blogs/machine-learning/extending-conversational-memory-in-kiro-cli-using-amazon-bedrock-agentcore-memory/

[2] Amazon Bedrock AgentCore Memory — Official Documentation — https://aws.amazon.com/bedrock/agentcore-memory/

[3] Kiro CLI — GitHub Repository — https://github.com/kiro-cli/kiro

[4] Building Context-Aware AI Agents — Towards Data Science — https://towardsdatascience.com/building-context-aware-ai-agents-5a2e3f4d1c8e

[5] Introducing Amazon Bedrock and Its Use Cases — AWS Blog — https://aws.amazon.com/blogs/aws/introducing-amazon-bedrock-and-its-use-cases/

[6] AWS Announces General Availability of Amazon Bedrock — InfoQ — https://www.infoq.com/news/2023/10/aws-bedrock-ga/