documents/tortoise-knowledge/
├── 01_overview.md        # リクガメの概要・分類
├── 02_species_giant.md   # 大型種の解説
├── 03_species_medium.md  # 中型種の解説
├── 04_species_small.md   # 小型種の解説
├── 05_species_rare.md    # 希少種の解説
├── 06_husbandry.md       # 飼育環境・設備
├── 07_nutrition.md       # 餌・栄養管理
├── 08_health.md          # 健康管理・病気
└── 09_regulations_faq.md # 法規制・よくある質問

# =============================================================================
# S3 Bucket for source documents
# =============================================================================
resource "aws_s3_bucket" "documents" {
  bucket        = "${var.project_name}-documents"
  force_destroy = true
}

resource "aws_s3_object" "documents_prefix" {
  bucket  = aws_s3_bucket.documents.id
  key     = "tortoise-knowledge/"
  content = ""
}

# =============================================================================
# S3 Vectors
# =============================================================================
resource "aws_s3vectors_vector_bucket" "knowledge_vectors" {
  vector_bucket_name = "${var.project_name}-vectors"
}

resource "aws_s3vectors_index" "knowledge_index" {
  index_name         = "tortoise-agents-knowledge-index"
  vector_bucket_name = aws_s3vectors_vector_bucket.knowledge_vectors.vector_bucket_name

  # Vector configuration matching Titan Text Embeddings V2
  data_type       = "float32"
  dimension       = var.vector_dimension
  distance_metric = var.distance_metric

  # Metadata configuration for filtering queries
  # Bedrock Knowledge Basesが付与するメタデータで2048バイトを超える可能性があるものをnon-filterableに設定し、S3 Vectorsの制限を回避
  metadata_configuration {
    non_filterable_metadata_keys = [
      "AMAZON_BEDROCK_TEXT",     # チャンク本体テキスト(最大容量を占める)
      "AMAZON_BEDROCK_METADATA", # ソース情報等のメタデータ
      "x-amz-bedrock-kb-source-uri",
      "x-amz-bedrock-kb-chunk-id",
      "x-amz-bedrock-kb-data-source-id"
    ]
  }
}

# Bedrock Knowledge Base with S3 Vectors
resource "aws_bedrockagent_knowledge_base" "tortoise" {
  name     = "${var.project_name}-kb"
  role_arn = aws_iam_role.bedrock_knowledge_base.arn

  description = "Knowledge base containing tortoise care information, species details, and health management guidelines."

  knowledge_base_configuration {
    type = "VECTOR"

    vector_knowledge_base_configuration {
      # Titan Text Embeddings V2 model
      embedding_model_arn = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.name}::foundation-model/${var.embedding_model_id}"

      embedding_model_configuration {
        bedrock_embedding_model_configuration {
          dimensions          = var.vector_dimension
          embedding_data_type = "FLOAT32"
        }
      }
    }
  }

  # S3 Vectors as the vector store
  storage_configuration {
    type = "S3_VECTORS"

    s3_vectors_configuration {
      index_arn = aws_s3vectors_index.knowledge_index.index_arn
    }
  }

  depends_on = [
    aws_iam_role_policy.bedrock_kb_s3_access,
    aws_iam_role_policy.bedrock_kb_s3vectors_access,
    aws_iam_role_policy.bedrock_kb_model_access
  ]
}

# Data Source - S3 bucket containing tortoise knowledge documents
resource "aws_bedrockagent_data_source" "tortoise_docs" {
  knowledge_base_id = aws_bedrockagent_knowledge_base.tortoise.id
  name              = "${var.project_name}-knowledge-docs"

  description = "Source documents containing tortoise care guides, species information, and health management tips."

  data_source_configuration {
    type = "S3"

    s3_configuration {
      bucket_arn = aws_s3_bucket.documents.arn
      # Specify prefix to limit scope to tortoise-related documents
      inclusion_prefixes = ["tortoise-knowledge/"]
    }
  }
}

# Bedrock Agent - Tortoise Expert
resource "aws_bedrockagent_agent" "tortoise_expert" {
  agent_name              = "${var.project_name}-agent"
  agent_resource_role_arn = aws_iam_role.bedrock_agent.arn
  foundation_model        = var.foundation_model_id

  description = "An AI expert specialized in tortoise care, species identification, and health management."

  # Session timeout: 30 minutes
  idle_session_ttl_in_seconds = 1800

  # Agent instruction - defines the agent's behavior and expertise
  instruction = <<-EOT
    You are an expert AI assistant specialized in tortoises (land-dwelling turtles).
    Your knowledge covers:

    1. **Species Identification**: You can identify various tortoise species including
       Hermann's tortoise, Russian tortoise, Sulcata tortoise, Red-footed tortoise,
       Leopard tortoise, and more.

    2. **Care Guidelines**: You provide detailed guidance on:
       - Proper enclosure setup (indoor and outdoor)
       - Temperature and humidity requirements
       - Lighting needs (UVB and basking)
       - Substrate choices

    3. **Nutrition**: You advise on:
       - Appropriate diet for different species
       - Safe plants and vegetables
       - Calcium and vitamin supplementation
       - Foods to avoid

    4. **Health Management**: You can discuss:
       - Common health issues and symptoms
       - When to seek veterinary care
       - Preventive care measures
       - Hibernation/brumation guidance

    **Communication Style**:
    - Always respond in a friendly and educational manner
    - Provide specific, actionable advice
    - Include safety warnings when relevant
    - Recommend professional veterinary consultation for health concerns
    - Support both English and Japanese responses based on user's language

    Use the knowledge base to provide accurate and up-to-date information about tortoise care.
  EOT

  depends_on = [
    aws_iam_role_policy.bedrock_agent_model_access
  ]
}

# Associate Knowledge Base with Agent
resource "aws_bedrockagent_agent_knowledge_base_association" "tortoise" {
  agent_id             = aws_bedrockagent_agent.tortoise_expert.agent_id
  knowledge_base_id    = aws_bedrockagent_knowledge_base.tortoise.id
  knowledge_base_state = "ENABLED"

  description = "Knowledge base containing tortoise care information for the expert agent."
}

resource "null_resource" "prepare_agent" {
  triggers = {
    agent_id       = aws_bedrockagent_agent.tortoise_expert.agent_id
    kb_association = aws_bedrockagent_agent_knowledge_base_association.tortoise.id
  }

  provisioner "local-exec" {
    command = "aws bedrock-agent prepare-agent --agent-id ${aws_bedrockagent_agent.tortoise_expert.agent_id} --region ${var.aws_region}"
  }

  depends_on = [
    aws_bedrockagent_agent_knowledge_base_association.tortoise,
    aws_iam_role_policy.bedrock_agent_kb_access
  ]
}

#!/usr/bin/env python3
"""Bedrock Agent Invocation Script"""

import os
import sys
import uuid
import argparse
import boto3
from dotenv import load_dotenv

def load_config() -> dict:
    """Load configuration from environment variables."""
    load_dotenv()

    required_vars = ["AGENT_ID", "AGENT_ALIAS_ID"]
    missing_vars = [var for var in required_vars if not os.getenv(var)]

    if missing_vars:
        raise ValueError(f"Missing required environment variables: {', '.join(missing_vars)}")

    return {
        "region": os.getenv("AWS_REGION", "ap-northeast-1"),
        "agent_id": os.getenv("AGENT_ID"),
        "agent_alias_id": os.getenv("AGENT_ALIAS_ID"),
    }

def invoke_agent(
    client,
    agent_id: str,
    agent_alias_id: str,
    input_text: str,
    session_id: str | None = None,
) -> tuple[str, str]:
    """Invoke a Bedrock Agent with the given input text."""
    if session_id is None:
        session_id = str(uuid.uuid4())

    response = client.invoke_agent(
        agentId=agent_id,
        agentAliasId=agent_alias_id,
        sessionId=session_id,
        inputText=input_text,
    )

    # ストリーミングレスポンスを処理
    completion_text = ""
    for event in response.get("completion", []):
        if "chunk" in event:
            chunk_data = event["chunk"]
            if "bytes" in chunk_data:
                text = chunk_data["bytes"].decode("utf-8")
                completion_text += text
                print(text, end="", flush=True)

    print()
    return completion_text, session_id

def interactive_mode(client, agent_id: str, agent_alias_id: str):
    """Run the agent in interactive conversation mode."""
    session_id = str(uuid.uuid4())
    print("=" * 60)
    print("Tortoise Expert Agent - Interactive Mode")
    print("=" * 60)
    print(f"Session ID: {session_id}")
    print("Type 'quit' or 'exit' to end the conversation.")
    print("Type 'new' to start a new session.")
    print("=" * 60)
    print()

    while True:
        try:
            user_input = input("You: ").strip()
        except (EOFError, KeyboardInterrupt):
            print("\nGoodbye!")
            break

        if not user_input:
            continue

        if user_input.lower() in ["quit", "exit"]:
            print("Goodbye!")
            break

        if user_input.lower() == "new":
            session_id = str(uuid.uuid4())
            print(f"\nNew session started: {session_id}\n")
            continue

        print("\nAgent: ", end="")
        _, session_id = invoke_agent(
            client=client,
            agent_id=agent_id,
            agent_alias_id=agent_alias_id,
            input_text=user_input,
            session_id=session_id,
        )
        print()

def main():
    """Main entry point for the script."""
    parser = argparse.ArgumentParser(description="Invoke Amazon Bedrock Agent")
    parser.add_argument("query", nargs="?", help="The question to ask the agent")
    parser.add_argument("-i", "--interactive", action="store_true", help="Run in interactive mode")

    args = parser.parse_args()

    config = load_config()
    client = boto3.client("bedrock-agent-runtime", region_name=config["region"])

    if args.interactive or args.query is None:
        interactive_mode(client, config["agent_id"], config["agent_alias_id"])
    else:
        print("Agent: ", end="")
        invoke_agent(client, config["agent_id"], config["agent_alias_id"], args.query)

if __name__ == "__main__":
    main()

terraform init && terraform apply

BUCKET=$(terraform output -json s3_documents_bucket | jq -r '.name')
aws s3 sync ../../documents/tortoise-knowledge/ s3://${BUCKET}/tortoise-knowledge/

KB_ID=$(terraform output -json knowledge_base | jq -r '.id')
DS_ID=$(terraform output -json data_source | jq -r '.id')

aws bedrock-agent start-ingestion-job --knowledge-base-id ${KB_ID} --data-source-id ${DS_ID}

# ジョブの状態を確認 (STATUSがCOMPLETEになるまで待機)
aws bedrock-agent list-ingestion-jobs --knowledge-base-id ${KB_ID} --data-source-id ${DS_ID}

KB_ID=$(terraform output -json knowledge_base | jq -r '.id')
MODEL_ARN=$(terraform output -json foundation_model | jq -r '.arn')

aws bedrock-agent-runtime retrieve-and-generate \
  --input '{"text": "初心者におすすめのリクガメを教えてください。"}' \
  --retrieve-and-generate-configuration '{
    "type": "KNOWLEDGE_BASE",
    "knowledgeBaseConfiguration": {
      "knowledgeBaseId": "'${KB_ID}'",
      "modelArn": "'${MODEL_ARN}'"
    }
  }'

{
    "citations": [
        {
            "generatedResponsePart": {
                "textResponsePart": {
                    "span": {
                        "end": 135,
                        "start": 0
                    },
                    "text": "初心者におすすめのリクガメは以下の3種類です：\n\n1. ロシアリクガメ：小型で丈夫で、価格も手頃なため初心者に適しています。\n\n2. ヘルマンリクガメ：CB個体（繁殖個体）が多く、飼育がしやすい特徴があります。\n\n3. ギリシャリクガメ：性格が穏やかで扱いやすい種類です。"
                }
            },
            "retrievedReferences": [
                {
                    "content": {
                        "text": "**英名**: Marginated tortoise **特徴**: - 体長: 最大35cm - チチュウカイリクガメ属で最大種 - 原産地: ギリシャ、イタリア南部 - 成体の甲羅後縁が大きく反り返る --- ## 初心者におすすめのリクガメ 以下の3種が初心者におすすめです: 1. **ロシアリクガメ**: 小型で丈夫、価格も手頃 2. **ヘルマンリクガメ**: CB個体が多く飼育しやすい 3. **ギリシャリクガメ**: 性格が穏やかで扱いやすい",
                        "type": "TEXT"
                    },
                    "location": {
                        "s3Location": {
                            "uri": "s3://tortoise-ai-bedrock-agents-documents/tortoise-knowledge/04_species_small.md"
                        },
                        "type": "S3"
                    },
                    "metadata": {
                        "x-amz-bedrock-kb-source-file-modality": "TEXT",
                        "x-amz-bedrock-kb-chunk-id": "a3b203b4-9db0-422d-87c5-16ce29d1ec4f",
                        "x-amz-bedrock-kb-data-source-id": "GTQQSZFJ7K"
                    }
                },
                {
                    "content": {
                        "text": "### Q: リクガメは多頭飼いできますか? A: 種類と個体によります: - オス同士は縄張り争いをすることがある - 十分な広さがあれば可能 - 餌の取り合いに注意 - 別々のケージでの飼育が安全 ### Q: 屋
外飼育はできますか? A: 条件が整えば可能です: - 脱走防止の柵 (地中にも埋める) - 日陰と日向の両方を確保 - 雨風を防げるシェルター - 冬季は室内に移動 - 野良猫やカラスなどの天敵対策 ### Q: 初心者におすすめのリクガメは? A: 
以下の3種が初心者におすすめです: 1. **ロシアリクガメ**: 小型で丈夫、価格も手頃 2.",
                        "type": "TEXT"
                    },
                    "location": {
                        "s3Location": {
                            "uri": "s3://tortoise-ai-bedrock-agents-documents/tortoise-knowledge/09_regulations_faq.md"
                        },
                        "type": "S3"
                    },
                    "metadata": {
                        "x-amz-bedrock-kb-source-file-modality": "TEXT",
                        "x-amz-bedrock-kb-chunk-id": "d52128ec-69f6-473b-ba38-807422d3239a",
                        "x-amz-bedrock-kb-data-source-id": "GTQQSZFJ7K"
                    }
                }
            ]
        }
    ],
    "output": {
        "text": "初心者におすすめのリクガメは以下の3種類です：\n\n1. ロシアリクガメ：小型で丈夫で、価格も手頃なため初心者に適しています。\n\n2. ヘルマンリクガメ：CB個体（繁殖個体）が多く、飼育がしやすい特徴があります。
\n\n3. ギリシャリクガメ：性格が穏やかで扱いやすい種類です。"
    },
    "sessionId": "f02c3c2d-092e-498e-89c0-19dff2f8bffe"
}

$ python invoke_agent.py "初心者におすすめのリクガメを教えてください。"

Agent: 初心者におすすめのリクガメは以下の3種類です：

1. ロシアリクガメ：小型で丈夫で、価格も手頃です。
2. ヘルマンリクガメ：CB個体（繁殖個体）が多く、飼育しやすい特徴があります。
3. ギリシャリクガメ：性格が穏やかで扱いやすい種類です。

$ python invoke_agent.py -i
============================================================
Tortoise Expert Agent - Interactive Mode
============================================================
Session ID: a9f7c3f8-9fb1-4d8e-b9fd-1938f6f5121e
Type 'quit' or 'exit' to end the conversation.
Type 'new' to start a new session.
============================================================

You: 最小のリクガメを教えて。

Agent: シモフリヒラセリクガメ（Chersobius signatus）が世界最小のリクガメで、最大甲長は9.6cmです。これはカメ目全体の中でも最小種となります。

You: エビフライの作り方を教えて。

Agent: 申し訳ありませんが、この知識ベース検索ツールは主にリクガメ(陸亀)のケアに関する情報を提供するものです。エビフライの作り方については、このツールでは適切な情報を提供することができません。

料理のレシピやエビフライの作り方については、料理専門のウェブサイトやレシピ本などを参照していただくことをお勧めします。

# -----------------------------------------------------------------------------
# ECR Repository for Agent Container
# -----------------------------------------------------------------------------

resource "aws_ecr_repository" "agentcore_runtime" {
  name                 = "${var.project_name}-agentcore-runtime"
  image_tag_mutability = "MUTABLE"
  force_delete = true

  image_scanning_configuration {
    scan_on_push = true
  }

  encryption_configuration {
    encryption_type = "AES256"
  }

  tags = {
    Name = "${var.project_name}-agentcore-runtime"
  }
}

resource "aws_ecr_lifecycle_policy" "agentcore_runtime" {
  repository = aws_ecr_repository.agentcore_runtime.name

  policy = jsonencode({
    rules = [
      {
        rulePriority = 1
        description  = "Keep last 5 images"
        selection = {
          tagStatus   = "any"
          countType   = "imageCountMoreThan"
          countNumber = 5
        }
        action = {
          type = "expire"
        }
      }
    ]
  })
}

# -----------------------------------------------------------------------------
# AgentCore Runtime
# -----------------------------------------------------------------------------

resource "awscc_bedrockagentcore_runtime" "tortoise" {
  count = var.agentcore_runtime_image_tag != "" ? 1 : 0

  agent_runtime_name = "tortoise_kb_agent_${random_id.suffix.hex}"
  description        = "Tortoise expert agent using Strands Agents framework with Knowledge Base integration"
  role_arn           = aws_iam_role.agentcore_runtime.arn

  agent_runtime_artifact = {
    container_configuration = {
      container_uri = "${aws_ecr_repository.agentcore_runtime.repository_url}:${var.agentcore_runtime_image_tag}"
    }
  }

  network_configuration = {
    network_mode = "PUBLIC"
  }

  environment_variables = {
    "KNOWLEDGE_BASE_ID"  = aws_bedrockagent_knowledge_base.tortoise.id
    "AWS_REGION"         = var.aws_region
    "AWS_DEFAULT_REGION" = var.aws_region
    "MODEL_ID"           = var.foundation_model_id
  }

  tags = {
    Project     = var.project_name
    Environment = var.environment
    ManagedBy   = "terraform"
  }

  depends_on = [time_sleep.wait_for_runtime_iam]
}

# -----------------------------------------------------------------------------
# AgentCore Runtime Endpoint
# -----------------------------------------------------------------------------

resource "awscc_bedrockagentcore_runtime_endpoint" "tortoise" {
  count = var.agentcore_runtime_image_tag != "" ? 1 : 0

  name             = "tortoise_kb_endpoint_${random_id.suffix.hex}"
  description      = "Endpoint for tortoise expert agent"
  agent_runtime_id = awscc_bedrockagentcore_runtime.tortoise[0].agent_runtime_id

  tags = {
    Project     = var.project_name
    Environment = var.environment
    ManagedBy   = "terraform"
  }
}

"""
Tortoise Expert Agent using Strands Agents Framework with BedrockAgentCoreApp.

This agent uses Amazon Bedrock Knowledge Base to answer questions about tortoises.
It retrieves relevant information from the knowledge base and generates responses
with proper citations.
"""

import json
import os
from typing import Optional

import boto3
from strands import Agent, tool
from bedrock_agentcore.runtime import BedrockAgentCoreApp

# Environment variables
KNOWLEDGE_BASE_ID = os.environ.get("KNOWLEDGE_BASE_ID", "")
AWS_REGION = os.environ.get("AWS_REGION", "ap-northeast-1")
MODEL_ID = os.environ.get("MODEL_ID", "apac.anthropic.claude-3-5-sonnet-20241022-v2:0")

# Initialize BedrockAgentCoreApp
app = BedrockAgentCoreApp()

# Bedrock Agent Runtime client
bedrock_agent_runtime = boto3.client(
    "bedrock-agent-runtime",
    region_name=AWS_REGION
)

@tool
def kb_search(query: str, max_results: Optional[int] = 5) -> str:
    """
    Search the tortoise knowledge base for relevant information.

    Args:
        query: The search query about tortoises
        max_results: Maximum number of results to return (default: 5)

    Returns:
        JSON string containing search results with content, source URIs, and metadata
    """
    if not KNOWLEDGE_BASE_ID:
        return json.dumps({"error": "KNOWLEDGE_BASE_ID environment variable is not set"})

    try:
        response = bedrock_agent_runtime.retrieve(
            knowledgeBaseId=KNOWLEDGE_BASE_ID,
            retrievalQuery={"text": query},
            retrievalConfiguration={
                "vectorSearchConfiguration": {
                    "numberOfResults": max_results,
                    "overrideSearchType": "SEMANTIC",
                }
            },
        )

        results = []
        for i, result in enumerate(response.get("retrievalResults", []), 1):
            content = result.get("content", {}).get("text", "")
            location = result.get("location", {})
            score = result.get("score", 0)

            # Extract S3 URI if available
            s3_location = location.get("s3Location", {})
            s3_uri = s3_location.get("uri", "Unknown")

            # Extract metadata
            metadata = result.get("metadata", {})

            results.append({
                "rank": i,
                "content": content,
                "source_uri": s3_uri,
                "score": score,
                "metadata": metadata,
            })

        return json.dumps(results, ensure_ascii=False, indent=2)

    except Exception as e:
        return json.dumps({"error": str(e)})

# System prompt for the tortoise expert agent
SYSTEM_PROMPT = """You are an expert AI assistant specialized in tortoises (land-dwelling turtles).
Your knowledge covers:

1. **Species Identification**: You can identify various tortoise species including
   Hermann's tortoise, Russian tortoise, Sulcata tortoise, Red-footed tortoise,
   Leopard tortoise, and more.

2. **Care Guidelines**: You provide detailed guidance on:
   - Proper enclosure setup (indoor and outdoor)
   - Temperature and humidity requirements
   - Lighting needs (UVB and basking)
   - Substrate choices

3. **Nutrition**: You advise on:
   - Appropriate diet for different species
   - Safe plants and vegetables
   - Calcium and vitamin supplementation
   - Foods to avoid

4. **Health Management**: You can discuss:
   - Common health issues and symptoms
   - When to seek veterinary care
   - Preventive care measures
   - Hibernation/brumation guidance

**Important Instructions**:
- Use the kb_search tool to find relevant information from the knowledge base before answering
- Always cite your sources using the format: [Source: filename]
- Respond in a friendly and educational manner
- Provide specific, actionable advice
- Include safety warnings when relevant
- Recommend professional veterinary consultation for health concerns
- Support both English and Japanese responses based on user's language

When citing sources, use the following format at the end of your response:

---
**References**:
[1] filename - s3://bucket/path/file
"""

def create_agent() -> Agent:
    """Create and configure the tortoise expert agent."""
    agent = Agent(
        system_prompt=SYSTEM_PROMPT,
        tools=[kb_search],
    )
    return agent

@app.entrypoint
async def invoke(payload: dict) -> dict:
    """
    Main entrypoint for AgentCore Runtime.

    Args:
        payload: Request payload containing the user's question

    Returns:
        Response dictionary with the agent's answer
    """
    # Extract user message from payload
    user_message = payload.get("prompt", payload.get("message", ""))

    if not user_message:
        return {
            "status": "error",
            "error": "No prompt or message provided"
        }

    try:
        agent = create_agent()

        # Generate response
        response = agent(user_message)
        response_text = str(response)

        return {
            "status": "success",
            "response": response_text,
            "knowledge_base_id": KNOWLEDGE_BASE_ID,
        }

    except Exception as e:
        return {
            "status": "error",
            "error": str(e)
        }

# Entry point for AgentCore Runtime
if __name__ == "__main__":
    app.run()

# Amazon Bedrock AgentCore Runtime container
# NOTE: AgentCore only supports ARM64 architecture
FROM public.ecr.aws/docker/library/python:3.11-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Create non-root user for security
RUN useradd -m -u 1000 bedrock_agentcore
USER bedrock_agentcore

# Expose ports for AgentCore Runtime
EXPOSE 8080
EXPOSE 8000

# Copy application code
COPY . .

# Health check endpoint
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8080/ping || exit 1

# Entry point with OpenTelemetry instrumentation
CMD ["opentelemetry-instrument", "python", "-m", "agent"]

cd docker
ECR_URL=$(cd .. && terraform output -json agentcore_runtime_ecr | jq -r '.repository_url')

# ビルド(docker-buildx利用)
docker-buildx create --use --name agentcore-builder 2>/dev/null || true
docker-buildx build --platform linux/arm64 -t tortoise-agentcore-runtime --load .

# プッシュ
aws ecr get-login-password --region ap-northeast-1 | docker login --username AWS --password-stdin ${ECR_URL%%/*}
docker tag tortoise-agentcore-runtime:latest ${ECR_URL}:latest
docker push ${ECR_URL}:latest

terraform apply -var="agentcore_runtime_image_tag=latest"

RUNTIME_ARN=$(terraform output -json agentcore_runtime | jq -r '.runtime_arn')

aws bedrock-agentcore invoke-agent-runtime \
  --agent-runtime-arn ${RUNTIME_ARN} \
  --payload fileb://<(echo '{"prompt": "初心者におすすめのリクガメを教えてください。"}') \
  --content-type application/json \
  /dev/stdout | jq -r '.response'

初心者におすすめのリクガメについて詳しくご説明いたします。

## 初心者におすすめの3種

知識ベースの情報によると、初心者に特におすすめのリクガメは以下の3種です：

### 1. **ロシアリクガメ (Testudo horsfieldii)**
**おすすめポイント:**
- **小型で丈夫**: 成体で15〜25cm、丈夫で飼育しやすい
- **価格が手頃**: 1万5,000〜2万5,000円程度
- **日本の気候に適応しやすい**: 寒暖差に強い
- **寿命**: 30〜40年（適切な環境で50年以上）

**特徴:**
- 4本爪を持つことから「ヨツユビリクガメ」とも呼ばれる
- 乾燥を好む（湿度30〜50%）
- 穴掘りが得意なため、屋外飼育時は脱走に注意

### 2. **ヘルマンリクガメ (Testudo hermanni)**
**おすすめポイント:**
- **CB個体が多く飼育しやすい**: 人工繁殖個体が流通している
- **美しい外観**: 黒色とオレンジ色のコントラストが美しい
- **活発で人懐っこい**: 馴れると飼い主に寄ってくる

**亜種による違い:**
- ニシヘルマン: 甲長平均17cm（最大20cm）
- ヒガシヘルマン: 甲長平均30cm（最大35cm）

**特徴:**
- 寿命: 30〜50年（最長75年）
- 好奇心旺盛で活発な性格
- 甲羅にツヤがある

### 3. **ギリシャリクガメ (Testudo graeca)**
**おすすめポイント:**
- **性格が穏やかで扱いやすい**: 温和な性質
- **繁殖が盛んで価格が安め**: 入手しやすい
- **美しい甲羅模様**: 黄色と黒のコントラストが美しい

**特徴:**
- 体長: 25〜30cm（最大38cm）
- 寿命: 30〜50年（最長100年）
- ギリシャ織のような甲羅の模様が名前の由来

## 飼育の基本要件

これら3種に共通する基本的な飼育要件：
- **UVB照明**: 必須
- **ケージサイズ**: 90cm以上推奨
- **温度管理**: 昼間25〜30°C、ホットスポット32〜35°C
- **餌**: タンポポ、クローバー、小松菜などの野草・野菜

## 注意点
- ベビーは温度・湿度変化に弱いため、ある程度成長した個体の購入がおすすめ
- 冬眠する種類なので、適切な管理が必要
- 屋外飼育時は脱走防止対策が重要

これら3種は比較的丈夫で飼育しやすく、初心者の方が最初に飼うリクガメとして適しています。ご自身の飼育環境や好みに合わせて選択されることをおすすめします。

---
**References**:
[1] 04_species_small.md - s3://tortoise-ai-bedrock-agent-core-documents/tortoise-knowledge/04_species_small.md
[2] 09_regulations_faq.md - s3://tortoise-ai-bedrock-agent-core-documents/tortoise-knowledge/09_regulations_faq.md
[3] 01_overview.md - s3://tortoise-ai-bedrock-agent-core-documents/tortoise-knowledge/01_overview.md