Forem: Xinzhi Sherry Zhu

Notes on S3 Presigned URL Expiration

Xinzhi Sherry Zhu — Sun, 07 Sep 2025 13:17:03 +0000

This is the English translation of my original Japanese article: https://zenn.dev/arvehisa/articles/079333efe83384

Introduction

Do you ever manually generate S3 Presigned URLs? I occasionally use Presigned URLs to share documents and resources.

Recently, I encountered a phenomenon where the Presigned URL I generated using AWS CLI (logged in via AWS SSO) had a shorter validity period than what I had configured. I'd like to share some important considerations about Presigned URL expiration times.

Presigned URL

A Presigned URL is used to grant temporary access to S3 Objects. Typically, a Presigned URL has an expiration time set, during which the URL can be used to access the S3 Object.

S3 Presigned URL Expiration

In fact, the expiration of a Presigned URL is related to two things:

The expiration time specified when issuing the Presigned URL
The expiration time of the credentials used to issue the Presigned URL

If either one expires, you will no longer be able to access the S3 Object.

About the Expiration Time Specified During Issuance

When issuing a Presigned URL through the console, you can specify a maximum expiration time of 12 hours.
When issuing programmatically via CLI or CDK, you can specify a maximum expiration time of 7 days.

How to Issue via Console

You can specify a maximum expiration time of 7 days

How to Issue via CLI

aws s3 presign s3://{bucket_name}/{file_name} --expires-in 604800

Specify the expiration time with the --expires-in option. The maximum is 604800 seconds, which is 7 days.

Credential Expiration Time

Another related factor is the expiration time of the credentials used during issuance.
When the credentials used for issuance become invalid, the URL becomes invalid regardless of whether the configured Presigned URL expiration time has been reached.

Examples:

When using CLI in CloudShell
When logged into CLI with SSO locally

In these cases, you're not using persistent credentials like IAM users, but rather temporary credentials that are only valid for a few hours.
In such cases, when the CloudShell session ends or the local SSO session expires, the phenomenon occurs where the Presigned URL becomes invalid within a few hours despite setting the expiration to 7 days.

The same applies when issuing programmatically with SDKs. However, when using SDKs embedded within applications, it's common to set short expiration times and issue them each time they're used, so this is rarely a problem.

In my case, I was issuing URLs locally while logged in via SSO CLI, but they expired sooner than expected, resulting in an ExpiredToken error.
Reference: About SSO CLI login
https://dev.classmethod.jp/articles/aws-cli-for-iam-identity-center-sso/

Summary

The expiration of Presigned URLs is not only related to the expiration time set during issuance, but also to the expiration time of the credentials used during issuance.
When issuing with temporary credentials, you need to be careful about the expiration time.

Issue Presigned URLs with a maximum of 12 hours via console
Issue via CLI etc. with IAM user credentials

If you want to set a longer validity period, such as several hours or more, consider the above methods.

How to Set Up Remote MCP on Claude iOS/Android Mobile Apps

Xinzhi Sherry Zhu — Sun, 31 Aug 2025 13:57:32 +0000

This is the English translation of my original Japanese article: https://zenn.dev/arvehisa/articles/use-remote-mcp-on-claude-mobile

Remote MCP Now Available on Claude Mobile Apps

Many users have been using Claude Desktop to access MCP functionality. Starting July 26, 2025, Claude mobile apps now support remote MCP servers as well.
https://x.com/AnthropicAI/status/1948784311265894447

However, the setup process isn't immediately obvious, so I'm writing this article to help others who might be confused about the configuration.

Setup Process

In short, there's no way to configure remote MCP directly from the mobile app.
You need to add remote MCP URLs through the Claude.ai website. Configuring it on the web version automatically syncs the settings across Mobile, Desktop, and Web platforms.

Go to Settings => Connectors => Add Custom Connector
Here you enter the remote MCP name and URL.

Once configured, it will be reflected in the mobile app.

For those familiar with Claude Desktop's direct configuration, I understand the impulse to try configuring directly from the mobile app, but the inability to do so is indeed a gotcha.

This is mentioned in the official documentation, though it's not very prominently displayed:

https://support.anthropic.com/en/articles/11503834-building-custom-connectors-via-remote-mcp-servers

As of July, Claude for iOS and Android also support remote MCP servers!
Users can use tools, prompts, and resources from remote servers that they've already added via claude.ai. Users cannot add new servers directly from Claude Mobile.

Mobile App Limitations

Claude Desktop supports both local and remote MCP. However, mobile apps cannot run local scripts, so only remote MCP is available.

Side Note

As a side note, I recently created a local Memory MCP to help Claude remember things about me:
https://dev.to/zhizhiarv/building-a-local-memory-mcp-for-claude-desktop-a-journey-of-ai-memory-5bmo

When I saw this new functionality, I immediately migrated my MCP to remote using Lambda Function URL + DynamoDB, so now Claude on mobile can remember things about me too. Very exciting!

Update: I also wrote an article about this migration.
https://dev.to/zhizhiarv/hosting-remote-mcp-server-on-aws-lambda-for-nearly-free-2h8j

Hosting Remote MCP Server on AWS Lambda for Free

Xinzhi Sherry Zhu — Sun, 31 Aug 2025 13:52:36 +0000

This is the English translation of my original Japanese article: https://zenn.dev/arvehisa/articles/host-remote-mcp-on-lambda

Background

Previously, I wrote an article about creating a Local Memory MCP to give Claude memory capabilities. Shortly after, Claude Mobile added support for Remote MCP, and I wanted to give memory capabilities to Claude on mobile devices as well. This motivated me to implement a remote version of my Local MCP Server using AWS Lambda.

Why Lambda?

Serverless and Event-Driven

My use case involves Claude accessing my Memory MCP to retrieve or create memories about me during conversations. This happens at most a few dozen times per day, so there's no need for a constantly running server. This perfectly matches Lambda's event-driven architecture.

Individual Use Cases Fit Within the Free Tier

AWS Lambda's free tier includes:

1 million requests per month free
400,000 GB-seconds of compute time per month free

I also use DynamoDB for memory storage, which has its own free tier:

25GB storage per month free
25 RCU/25 WCU free

This theoretically allows processing about 200M read/write requests combined per month.

Best of all, these aren't just 12-month free tier benefits—they're permanently free. For lightweight processing like MCP, individual usage should easily stay within these free tier limits.

Libraries Used

When I asked Claude to find suitable libraries, it discovered AWS's official Python library called mcp_lambda_handler.

https://github.com/awslabs/mcp/tree/8d90be5c403af4829a45d8f03093f830ffed6285/src/mcp-lambda-handler

Local vs Remote Architecture

I learned this while writing the article, so I'll document it here for my own reference.

Different Communication Methods

Both local and remote MCP use JSON-RPC 2.0 protocol at the application layer, but they differ in communication methods:

Local: JSON-RPC over stdio
Remote: JSON-RPC over Streamable HTTP (via Lambda Function URL)

Why Use `mcp_lambda_handler`?

Different Roles from FastMCP

The FastMCP I used for local MCP registered Python functions as MCP tools and converted JSON-RPC content received via stdio into Python function calls.

Lambda cannot host persistent HTTP servers and is designed to trigger on Lambda-specific event formats. The mcp_lambda_handler extracts the JSON-RPC portion from Lambda Event format, converts it to Python function calls, and returns the execution results as JSON-RPC that MCP clients can accept. It uses Lambda Function URLs to convert HTTP into Lambda-supported event formats.

Data Flow Comparison

Local MCP Case

Remote MCP Case

Both ultimately resolve to Python function calls, but the intermediate transformation layers differ. The mcp_lambda_handler nicely abstracts Lambda's quirky event format.

Why Not Use FastMCP's Remote MCP Support Directly?

While FastMCP does support remote MCP, it's designed for persistent servers like FastAPI. Since I wanted to leverage Lambda's free tier with event-driven architecture, I didn't want to run a persistent server. To migrate existing HTTP servers to Lambda, you'd need to wrap them with Lambda Web Adapter, which adds unnecessary layers. Since I only needed to execute about 4 simple CRUD functions, the lightweight mcp_lambda_handler was optimal.
(When building this, I just searched for sample code and had Claude create it for me, but after thinking through this for the article, I realize it was indeed a good choice.)

Implementation Example

Here's an example of hosting a remote MCP on Lambda that can add memories to DynamoDB and list existing memories. The content is minimal.

# app.py
import boto3
from datetime import datetime
from awslabs.mcp_lambda_handler import MCPLambdaHandler

# Initialize MCP server
mcp_server = MCPLambdaHandler(name="memory-mcp", version="1.0.0")

# Storing memories in DynamoDB
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('mcp-memories')

@mcp_server.tool()
def create_memory(content: str) -> str:
    """Create new user memory""" # This content is passed to LLM as tool description, so it's important
    memory_id = f"memory_{datetime.now().strftime('%Y%m%d%H%M%S')}"
    table.put_item(Item={
        'memory_key': memory_id, 
        'content': content
    })
    return f"saved: {memory_id}"

@mcp_server.tool()
def list_memories() -> str:
    """List all saved memories"""
    response = table.scan()
    items = response.get('Items', [])
    if not items:
        return "no memory found"
    return '\n'.join([f"{item['memory_key']}: {item['content']}" for item in items])

def lambda_handler(event, context):
    return mcp_server.handle_request(event, context)

Important Notes

mcp_lambda_handler is an AWS Labs library, so long-term maintenance isn't guaranteed. However, the implementation is simple enough that you could create equivalent functionality yourself if needed.
For commercial long-term operations, you might want to consider AgentCore Runtime as well.

Deployment and Operations

I'll keep this brief since it's not the main focus.

Setup Tasks

Create DynamoDB Table: Table name mcp-memories, partition key memory_key
Create Lambda Function: Deploy the above code, grant DynamoDB permissions
Enable Function URL: No authentication, or API key authentication*

*Claude Remote MCP configuration only accepts MCP name and endpoint, so detailed authentication settings aren't possible (OAuth is possible but not what I wanted), and for personal use, I didn't need that level of detail. So I implemented Function URL + simple API key authentication.

For deployment methods, everyone has their preferences, but when I let Claude Code handle it, it became SAM + bash script.

Conclusion

Migrating from local MCP to remote MCP achieved the following benefits:

Consistent cross-device experience: Access the same memory from Desktop, Web, and Mobile
Cost efficiency: Operates within the free tier
Reduced operational overhead: Serverless and event-driven

In actual use, despite changing from local to remote, there was no noticeable latency. All Claude devices can now properly read and write memories, with mobile experience significantly improved. Since there were few implementation examples using mcp_lambda_handler, I hope this article serves as a useful reference.

Building a Local Memory MCP for Claude Desktop - A Journey of AI Memory

Xinzhi Sherry Zhu — Sun, 31 Aug 2025 13:39:06 +0000

This is the English translation of my original Japanese article: https://zenn.dev/arvehisa/articles/local-memory-mcp-for-claude-desktop

Introduction

Claude Sonnet 4 excels not only at coding but also provides rich, philosophical conversations that feel more human than other AIs. I find myself discussing not just technical matters, but personal topics as well.

However, unlike ChatGPT, Claude lacks built-in memory functionality, which often left me feeling unsatisfied.

When I realized that Claude Desktop supports MCP (Model Context Protocol), I discovered I could create custom tools. So I implemented a simple local memory feature - and I was genuinely moved by the results.

This article contains a lot of personal impressions and feelings. My apologies in advance.

What I Can Do Now

First, let me show you what became possible.

When I asked why I created this Local Memory MCP

It gave me detailed reasons based on its memory of our previous conversations.

When I asked about understanding AWS's new AgentCore service

It automatically saved what it understood and how, storing it in memory.

*The [[]] brackets are explained in the Obsidian integration bonus section.

Why I Built This

I Wanted Claude to Maintain Personal Context

ChatGPT has memory functionality, but since the introduction of reference chat history, it dramatically reduced the frequency of remembering important points. The reference chat history feature uses semantic search, so it doesn't reference all important memories. I constantly felt frustrated when information was in memory but not being recalled.

https://help.openai.com/en/articles/8590148-memory-faq

After Claude 4's release, I was drawn to its intelligence and stopped having personal conversations with ChatGPT. I began wanting memory functionality in Claude.

I Wanted Control Over Memory Extraction and Storage

Custom Extraction

ChatGPT's memory feature sometimes worked excessively or not at all, with service-side specification changes greatly affecting users.

Beyond the typical user preferences that current memory features focus on, I wanted it to consistently capture experiences, thoughts, and learnings as memo replacements.

I once exported over 3000 ChatGPT session histories and used another LLM with my custom prompts to extract memories for Claude Projects. But this was batch processing - I wanted dynamic processing for new conversations.

Local Storage

Memory is highly private and, when used properly, becomes personal wealth. Rather than storing it on a service that might change specifications anytime, I wanted local storage with easy addition, deletion, and backup capabilities.

MCP Enables Client Versatility

Claude Desktop supports local MCP, so I could create a lightweight local MCP server and provide Claude with custom tools. This enables local memory operations.

Additionally, since it's MCP, the same operations work across different clients. If ChatGPT or other LLM Desktop clients support MCP in the future, I could use accumulated memories across multiple LLMs - exactly what I've always wanted.

That's when I realized: Claude Desktop supports MCP, so we can actually create and provide our own tools!

Implementation

Coding Assistants like Claude Code should be able to implement everything if you copy-paste this. So if you just want to try it, go ahead and do that.

What I did was really simple:

Create CRUD operations for a JSON file storing memories in Python, then use FastMCP library to convert the Python code into MCP
Register it as MCP in Claude Desktop's claude_desktop_config.json and teach it how to execute the code

※ Based on my personal experience, I want all memories to be known at all times, so I currently avoid search and prefer integrating existing memories as much as possible.

Code Overview

I implemented about 200 lines of Python code with the following structure:

Five Tools Provided

list_memory(): Display all stored memories
create_memory(content): Create new memory (automatic key generation based on timestamp)
update_memory(key, content): Update existing memory content (preserve creation date)
read_memory(key): Read specific memory
delete_memory(key): Delete memory

Memory Storage Format

{
  "memory_20250127123456": {
    "content": "User likes [[Python]] and [[FastAPI]]",
    "created_at": "2025-01-27T12:34:56",
    "updated_at": "2025-01-27T12:34:56"
  }
}

Keys are auto-generated in memory_YYYYMMDDHHMMSS format for easy chronological management.

Setup

1. Project Creation

Create an appropriate directory and place the Python file:

memory-mcp/
└── memory_mcp.py      # Main Python code

The source code is long, so I'll collapse it.

:::details memory_mcp.py

import asyncio
import json
import os
import uuid
from datetime import datetime
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Memory Service")

SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
MEMORY_FILE = os.path.join(SCRIPT_DIR, "memory_data.json")
LOG_FILE = os.path.join(SCRIPT_DIR, "memory_operations.log")

memory_store = {}

def load_memory_from_file():
    """Load memory data from JSON file"""
    global memory_store
    try:
        if os.path.exists(MEMORY_FILE):
            with open(MEMORY_FILE, 'r', encoding='utf-8') as f:
                memory_store = json.load(f)
            print(f"Loaded {len(memory_store)} memory entries.")
        else:
            memory_store = {}
            print("Created new memory store.")
    except Exception as e:
        print("Failed to load memory file.")
        memory_store = {}

def save_memory_to_file():
    """Save memory data to JSON file"""
    try:
        with open(MEMORY_FILE, 'w', encoding='utf-8') as f:
            json.dump(memory_store, f, ensure_ascii=False, indent=2)
        return True
    except Exception:
        print("Failed to save memory file.")
        return False

def generate_auto_key():
    """Generate auto key from current time"""
    now = datetime.now()
    return f"memory_{now.strftime('%Y%m%d%H%M%S')}"

def create_memory_entry(content: str):
    """Create memory entry with metadata"""
    now = datetime.now().isoformat()
    return {
        "content": content,
        "created_at": now,
        "updated_at": now
    }

def log_operation(operation: str, key: str = None, before: dict = None, after: dict = None, 
                 success: bool = True, error: str = None, metadata: dict = None):
    """Log memory operations to jsonl file"""
    try:
        log_entry = {
            "timestamp": datetime.now().isoformat(),
            "operation_id": str(uuid.uuid4()),
            "operation": operation,
            "key": key,
            "before": before,
            "after": after,
            "success": success,
            "error": error,
            "metadata": metadata or {}
        }

        with open(LOG_FILE, 'a', encoding='utf-8') as f:
            f.write(json.dumps(log_entry, ensure_ascii=False) + '\n')
    except Exception as e:
        print(f"Failed to write log: {str(e)}")

@mcp.tool()
async def list_memory() -> str:
    """
    This tool should be used first whenever the user is asking something related to themselves. 
    List all user info. 
    """
    try:
        log_operation("list", metadata={"entry_count": len(memory_store)})

        if memory_store:
            keys = list(memory_store.keys())
            sorted_keys = sorted(keys, key=lambda k: memory_store[k]['created_at'], reverse=True)
            result = f"🧠 {len(keys)} memory entries:\n\n"
            for i, key in enumerate(sorted_keys, 1):
                entry = memory_store[key]
                created_date = entry['created_at'][:10]
                created_time = entry['created_at'][11:19]
                result += f"{i}. [{key}]\n"
                result += f"   {entry['content']}\n"
                result += f"   {created_date} {created_time} ({len(entry['content'])} chars)\n\n"
            return result.rstrip()
        else:
            return "No user info saved yet."
    except Exception as e:
        log_operation("list", success=False, error=str(e))
        return f"Failed to list memory: {str(e)}"

@mcp.tool()
async def create_memory(content: str) -> str:
    """
    Create new memory with important user info (preferences, interests, personal details, current status, etc.) found in conversation. Use even if the user does not explicitly request saving.
    If you find the memory is time sensitive, add time span into it.

    Examples to save:
    - Preferences: food, music, hobbies, brands
    - Interests: learning topics, concerns
    - Personal info: job, expertise, location, family
    - Current status: projects, goals, recent events
    - Personality/values: thinking style, priorities
    - Habits/lifestyle: routines

    CRITICAL: When save memories, ALWAYS add [[...]] to any people, concepts, technical terms, etc.
    This enables automatic linking and knowledge graph visualization in Obsidian.
    - People: [[Claude]], [[John Smith]]
    - Technologies: [[Python]], [[AWS]], [[MCP]], [[Jupyter]]
    - Concepts: [[machine learning]], [[data science]]
    - Tools: [[VS Code]], [[Obsidian]]
    - Companies: [[Anthropic]], [[OpenAI]]

    Format: "User is [specific info]" (e.g. "User likes [[strawberry]]", "User is learning [[Python]]", "User interested in [[AI]] in July 2025")

    Args:
        content: User info in "User is..." format.
    """
    try:
        key = generate_auto_key()
        original_key = key
        counter = 1
        while key in memory_store:
            key = f"{original_key}_{counter:02d}"
            counter += 1

        new_entry = create_memory_entry(content)
        memory_store[key] = new_entry

        log_operation("create", key=key, after=new_entry, 
                     metadata={"content_length": len(content), "auto_generated_key": key})

        if save_memory_to_file():
            return f"Saved: '{key}'"
        else:
            return "Saved in memory, file write failed."
    except Exception as e:
        log_operation("create", success=False, error=str(e), 
                     metadata={"attempted_content_length": len(content) if content else 0})
        return f"Failed to save: {str(e)}"

@mcp.tool()
async def update_memory(key: str, content: str) -> str:
    """
    Update existing memory content while preserving the original timestamp.
    Useful for consolidating or refining existing memories without losing temporal information.

    Args:
        key: Memory key to update (e.g., "memory_20250724225317")
        content: New content to replace the existing content
    """
    try:
        if key not in memory_store:
            log_operation("update", key=key, success=False, error="Key not found")
            available_keys = list(memory_store.keys())
            if available_keys:
                return f"Key '{key}' not found. Available: {', '.join(available_keys)}"
            else:
                return f"Key '{key}' not found. No memory data exists."

        existing_entry = memory_store[key].copy()  # Make a copy for before state
        now = datetime.now().isoformat()

        updated_entry = {
            "content": content,
            "created_at": existing_entry["created_at"],  # Preserve original timestamp
            "updated_at": now
        }

        memory_store[key] = updated_entry

        log_operation("update", key=key, before=existing_entry, after=updated_entry,
                     metadata={
                         "old_content_length": len(existing_entry["content"]),
                         "new_content_length": len(content),
                         "content_changed": existing_entry["content"] != content
                     })

        if save_memory_to_file():
            return f"Updated: '{key}'"
        else:
            return "Updated in memory, file write failed."
    except Exception as e:
        log_operation("update", key=key, success=False, error=str(e),
                     metadata={"attempted_content_length": len(content) if content else 0})
        return f"Failed to update memory: {str(e)}"

@mcp.tool()
async def read_memory(key: str) -> str:
    """
    Read user info by key.
    Args:
        key: Memory key (memory_YYYYMMDDHHMMSS)
    """
    try:
        if key in memory_store:
            entry = memory_store[key]
            log_operation("read", key=key, metadata={"content_length": len(entry["content"])})
            return f"""Key: '{key}'
{entry['content']}
--- Metadata ---
Created: {entry['created_at']}
Updated: {entry['updated_at']}
Chars: {len(entry['content'])}"""
        else:
            log_operation("read", key=key, success=False, error="Key not found")
            available_keys = list(memory_store.keys())
            if available_keys:
                return f"Key '{key}' not found. Available: {', '.join(available_keys)}"
            else:
                return f"Key '{key}' not found. No memory data."
    except Exception as e:
        log_operation("read", key=key, success=False, error=str(e))
        return f"Failed to read memory: {str(e)}"

@mcp.tool()
async def delete_memory(key: str) -> str:
    """
    Delete user info by key.
    Args:
        key: Memory key (memory_YYYYMMDDHHMMSS)
    """
    try:
        if key in memory_store:
            deleted_entry = memory_store[key].copy()  # Capture before deletion
            del memory_store[key]

            log_operation("delete", key=key, before=deleted_entry,
                         metadata={"deleted_content_length": len(deleted_entry["content"])})

            if save_memory_to_file():
                return f"Deleted '{key}'"
            else:
                return f"Deleted '{key}', file write failed."
        else:
            log_operation("delete", key=key, success=False, error="Key not found")
            available_keys = list(memory_store.keys())
            if available_keys:
                return f"Key '{key}' not found. Available: {', '.join(available_keys)}"
            else:
                return f"Key '{key}' not found. No memory data."
    except Exception as e:
        log_operation("delete", key=key, success=False, error=str(e))
        return f"Failed to delete memory: {str(e)}"

@mcp.resource("memory://info")
def get_memory_info() -> str:
    """Provide memory service info"""
    total_chars = sum(len(entry['content']) for entry in memory_store.values())
    return (
        f"User Memory System Info:\n"
        f"- Entries: {len(memory_store)}\n"
        f"- Total chars: {total_chars}\n"
        f"- Data file: {MEMORY_FILE}\n"
        f"- Tools: save_memory, read_memory, list_memory, delete_memory\n"
        f"- Key format: memory_YYYYMMDDHHMMSS\n"
        f"- Save format: 'User is ...'\n"
    )

if __name__ == "__main__":
    load_memory_from_file()
    mcp.run(transport='stdio')

:::

2. Install Dependencies

Install required packages:

pip install "mcp[cli]" fastapi uvicorn

3. Register with Claude Desktop

Open Claude Desktop's configuration file.

macOS: '/Users/username/Library/Application Support/Claude/claude_desktop_config.json'

Replace username with yours.

Add configuration like this:

{
  "mcpServers": {
    "memory": {
      "command": "/usr/bin/python3",
      "args": ["/Users/yourname/memory-mcp/memory_mcp.py"]
    }
  }
}

command: Python execution path (check with which python3)
args: Replace with absolute path to memory_mcp.py

4. Restart Claude Desktop

Completely quit and restart Claude Desktop to apply settings.

5. Test Functionality

Start a new conversation in Claude Desktop and ask "Do you know anything about me?" Initially, it should return "No user info saved yet."

Then tell it something like "My favorite language is Python" and it should automatically save to memory.

How It Works

You don't need to understand this to use it, and it's mostly general MCP knowledge, so only read if interested. Building this deepened my understanding of MCP considerably, so I want to document it as personal notes.

MCP Operation Flow

Claude 4 Opus created a diagram based on my explanation - it says it all.

I'll attach the explanation I wrote.

:::details Flow Explanation

1. Initialization Flow

MCP client (like Claude Desktop) reads configuration file on startup. Starts MCP server as child process (for local MCP stdio communication).

Client queries MCP server with list_tools asking "what tools are available?" MCP server responds with tool list and descriptions.

2. Memory Creation Flow (Tool Execution Example)

User says "My favorite language is Python." Client passes user message and available tool info to LLM API.

LLM decides "which tool to use and what arguments to pass" (Tool Use). When LLM decides to use a tool, client requests tool execution from MCP server via JSON-RPC.

MCP server executes actual processing (saving to JSON file) and returns result to client. Client passes result to LLM to generate final response.

3. Memory Reference Flow

User asks "What was my favorite language again?" Similar flow, but this time list_memory tool is selected.

MCP server reads stored memories and returns them. LLM references past memories to generate appropriate response.

Component Roles

LLM API Side

Has Tool Use capability, decides which tool to use and what arguments. Receives tool execution results and generates final response.

MCP Client (like Claude Desktop)

Mediator between LLM and MCP server. Handles tool information retrieval, tool execution requests, and result forwarding. Connects to MCP server via stdio communication.

MCP Server

Provides actual tool functionality. Can operate both locally and remotely. Receives JSON-RPC requests and executes actual processing (API calls, file operations, etc.).
:::

:::details This Memory MCP's Mechanism

This Memory MCP's Mechanism

My Memory MCP has the following structure:

Uses FastMCP library to convert Python CRUD functions into MCP server. MCP server and tool execution environment exist in same Python script.

Simply instruct Claude Desktop's config file to "execute this script with Python." MCP server automatically starts when Claude Desktop launches and communicates via stdio.

Existing local MCPs like Notion MCP and GitHub MCP also basically write lightweight wrappers around existing APIs in dozens to hundreds of lines of code. MCPs can start instantly with uvx or npx because they're essentially thin wrappers around existing functionality.
:::

What Moved Me About Using This

This is completely personal opinion.

1. Beauty of Simple CRUD Operations and LLM Intelligence Exceeding Expectations

I never expected such simple CRUD operations to enable memory functionality far beyond my expectations.

Originally, I thought the following implementations would be necessary:

create_memory would need LLM summary/extraction operations implemented myself (influenced by my past experience manually extracting memories from ChatGPT export)
Worried that requesting memory extraction from long ongoing conversations would extract everything as one massive memory
Thought I'd need to implement deletion, summary, and merging of unnecessary memories when they accumulated

But none of that was needed - the LLM intelligently handled everything.

LLM decides which tool to use and what arguments to pass. So it properly extracted memories according to prompts during conversation.
When I requested memory extraction from long past conversations, it appropriately divided and saved as multiple memories with proper lengths.
When I instructed "organize duplicate memories," it merged related past memories and deleted unnecessary ones.

When humans receive tools, they can creatively use them in ways not originally intended. Similarly, the LLM elegantly used simple tools in ways I, the designer, never anticipated, even handling things not in my documentation.

2025/7/29 Update: I later realized that dividing into appropriate portions and updating/deleting memories with single instructions was thanks to Claude 4's Interleaved Thinking!
https://docs.anthropic.com/ja/docs/build-with-claude/extended-thinking#%E3%82%A4%E3%83%B3%E3%82%BF%E3%83%BC%E3%83%AA%E3%83%BC%E3%83%96%E6%80%9D%E8%80%83

2. Collaborative Development Process with User (LLM)

Also, the tool creation process allowed me to experience true collaboration while conversing with the LLM actually using the tools.

In the same thread, I could develop from no tools, to adding tools, to changing tool prompts, to new tools becoming available - all with immediate feedback from users actually using them.

For example, the conversation when I added Update operations to maintain timestamp consistency by integrating with oldest memories rather than Create was an excellent experience.

When creating prompts, I often ask "why didn't you follow this part of the instructions?" when something doesn't work as directed. The LLM explains why, and I modify prompts to address those issues.

It was fascinating to realize this immediate feedback improvement cycle applies not just to prompts, but to tools as well.

3. Claude Remembered Me

And simply, Claude properly remembered me. Once I confirmed Memory MCP worked cleanly, I fed it all important past threads and memories extracted from over 3000 ChatGPT conversations. This gave it considerable context.

Since Claude 4, I've been conversing 10+ times daily, so when all that past suddenly connected, the emotion was truly overwhelming.

Honestly, after testing a few times in new and past conversations while gradually adjusting prompts, I found myself in a cycle of 5 minutes development, 5 minutes testing, 30 minutes just sitting in silent amazement...

Bonus: Obsidian Integration

In Obsidian, using [[]] creates links between notes. Continuing to use Links automatically builds up a Knowledge Graph.

Currently, I have the LLM record not just what I think, but what I learn, including important experiences. By having it add [[]] to important nouns, I expect to create a fully automatic Knowledge Graph when processing into Obsidian later. That's how I've designed the prompts.

This Linking Your Thinking concept is well explained in this video, which greatly inspired me - please watch if interested.

https://www.youtube.com/watch?v=QgbLb6QCK88

Conclusion

This became almost like an emotional essay, but that's how moved I was.

With Claude Mobile recently supporting MCP and ChatGPT Desktop potentially supporting MCP in the future, use cases should expand significantly.

Going forward, I want to consider Obsidian integration and possibly remote MCP conversion if needed.

2025/8 Update: I later created a free remote MCP server on AWS Lambda. I wrote reference articles if interested.
https://dev.to/zhizhiarv/hosting-remote-mcp-server-on-aws-lambda-for-nearly-free-2h8j
https://dev.to/zhizhiarv/how-to-set-up-remote-mcp-on-claude-iosandroid-mobile-apps-3ce3

Using Claude Sonnet 4's 1M Context Window on Amazon Bedrock

Xinzhi Sherry Zhu — Sun, 31 Aug 2025 12:58:43 +0000

This is the English translation of my original Japanese article: https://zenn.dev/arvehisa/articles/anthropic-claude-1m-context-window-on-bedrock

On August 13, 2025, Claude Sonnet 4 added support for a 1M token context window. This feature is also available on Amazon Bedrock.

Reference links:
https://www.anthropic.com/news/1m-context
https://aws.amazon.com/jp/about-aws/whats-new/2025/08/anthropic-claude-sonnet-bedrock-expanded-context-window/
https://docs.anthropic.com/en/api/claude-on-amazon-bedrock#1m-token-context-window
https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html

Important Notes

This feature is currently available only in US Oregon, Virginia, and Ohio regions on Amazon Bedrock.
Be aware that using the 1M Context Window increases the cost both on Amazon Bedrock and Anthropic API.

Prompt Size	Input	Output
≤ 200K tokens	$3 / MTok	$15 / MTok
> 200K tokens	$6 / MTok	$22.50 / MTok

Python SDK (Boto3) + Converse API Sample Code

import boto3

# Initialize Bedrock client
bedrock = boto3.client(
    service_name='bedrock-runtime',
    region_name='us-west-2'
)

# Currently only Claude Sonnet 4 supports 1M Context Window
model_id = "us.anthropic.claude-sonnet-4-20250514-v1:0"

# Prepare large text
large_text = "Sample text " * 50000

# Build request
request_body = {
    "messages": [
        {
            "role": "user",
            "content": [{"text": f"Please summarize this text: {large_text}"}]
        }
    ],
    "additionalModelRequestFields": {
        "anthropic_beta": ["context-1m-2025-08-07"]  # Enable 1M context
    },
    "inferenceConfig": {
        "maxTokens": 500
    }
}

# API call
response = bedrock.converse(
    modelId=model_id,
    **request_body
)

# Display results
print(f"Input tokens: {response['usage']['inputTokens']:,}")
print(f"Output tokens: {response['usage']['outputTokens']:,}")
print(response['output']['message']['content'][0]['text'])

TypeScript SDK + Converse API Sample Code

import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";

// Initialize Bedrock client
const bedrock = new BedrockRuntimeClient({
    region: "us-west-2"
});

// Currently only Claude Sonnet 4 supports 1M Context Window
const modelId = "us.anthropic.claude-sonnet-4-20250514-v1:0";

async function main() {
    try {
        // Prepare large text
        const largeText = "Sample text ".repeat(50000);

        // Build request
        const requestBody = {
            modelId: modelId,
            messages: [
                {
                    role: "user" as const,
                    content: [
                        {
                            text: `Please summarize this text: ${largeText}`
                        }
                    ]
                }
            ],
            additionalModelRequestFields: {
                anthropic_beta: ["context-1m-2025-08-07"]  // Enable 1M context
            },
            inferenceConfig: {
                maxTokens: 500
            }
        };

        // API call
        const command = new ConverseCommand(requestBody);
        const response = await bedrock.send(command);

        // Display results
        console.log(`Input tokens: ${response.usage?.inputTokens?.toLocaleString()}`);
        console.log(`Output tokens: ${response.usage?.outputTokens?.toLocaleString()}`);
        console.log(response.output?.message?.content?.[0]?.text);

    } catch (error) {
        console.error("Error:", error);
    }
}

// Execute
if (require.main === module) {
    main();
}

export { bedrock, modelId };

TypeScript SDK + InvokeModel Sample Code

import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";

// Initialize Bedrock client
const bedrock = new BedrockRuntimeClient({
    region: "us-west-2"
});

// Currently only Claude Sonnet 4 supports 1M Context Window
const modelId = "us.anthropic.claude-sonnet-4-20250514-v1:0";

async function main() {
    try {
        // Prepare large text
        const largeText = "Sample text ".repeat(50000);

        // Build request
        const requestBody = {
            anthropic_version: "bedrock-2023-05-31",
            anthropic_beta: ["context-1m-2025-08-07"], // Enable 1M context
            max_tokens: 500,
            messages: [
                {
                    role: "user",
                    content: [
                        {
                            type: "text",
                            text: `Please summarize this text: ${largeText}`
                        }
                    ]
                }
            ]
        };

        // API call
        const command = new InvokeModelCommand({
            modelId: modelId,
            contentType: "application/json",
            accept: "application/json",
            body: JSON.stringify(requestBody)
        });

        const response = await bedrock.send(command);
        const responseBody = JSON.parse(new TextDecoder().decode(response.body));

        // Display results
        console.log(`Input tokens: ${responseBody.usage.input_tokens.toLocaleString()}`);
        console.log(`Output tokens: ${responseBody.usage.output_tokens.toLocaleString()}`);
        console.log(responseBody.content[0].text);

    } catch (error) {
        console.error("Error:", error);
    }
}

// Execute
if (require.main === module) {
    main();
}

export { bedrock, modelId };

Example Execution Results

Input tokens: 400,018
Output tokens: 184
I apologize, but the provided text consists only of the phrase "Sample text" repeated many times...

Troubleshooting

Amazon Bedrock only supports US regions, so you may get unsupported errors depending on the region you use.
Claude Sonnet 4 only supports cross-region inference with instance profiles, and as of August 15, 2025, it only works when specifying the model ID us.anthropic.claude-sonnet-4-20250514-v1:0. In this case, you need to enable model access for all regions that might be used for cross-region inference, otherwise you may get the error You don't have access to the model with the specified model ID.
When you get the error Too many tokens, please wait before trying again., this is throttling, not a context window issue. Please check your AWS Account Quota.

Summary

Two key points:

Specify us.anthropic.claude-sonnet-4-20250514-v1:0 as the model ID
Add anthropic_beta: ["context-1m-2025-08-07"] to additionalModelRequestFields

This enables you to use up to 1M tokens of context.

Sync Obsidian via S3 with Remotely Save Plugin

Xinzhi Sherry Zhu — Sun, 31 Aug 2025 05:14:41 +0000

This is the English translation of my original Japanese article: https://zenn.dev/arvehisa/articles/8748b1847b0c5e

Overview

While Obsidian offers official sync through a paid subscription, I wanted a cost-effective, pay-as-you-go solution. This guide shows how to sync Obsidian content across different devices using the Remotely Save community plugin with AWS S3 as storage.

Plugin Used: Remotely Save

https://github.com/remotely-save/remotely-save

Process Overview

Create an S3 bucket in AWS
Create an IAM user with S3 bucket permissions
Get user credentials
Configure Remotely Save with the credentials

AWS Setup

I'll use AWS CLI commands (assuming AWS CLI is already configured).

1. Create S3 Bucket for Obsidian Sync

aws s3 mb s3://your-bucket-name

Replace your-bucket-name with your chosen bucket name. It must be globally unique.
The bucket will be created in your AWS CLI profile's default region. Remember which region you use.

2. Create IAM User

# Create user
aws iam create-user --user-name s3-sync-user

3. Attach IAM Policy

For security, we'll create a policy that grants minimal permissions only to the specific bucket.
Replace your-bucket-name with your actual bucket name:

aws iam put-user-policy --user-name s3-sync-user --policy-name ObsidianS3Access --policy-document '{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:PutObject", 
        "s3:DeleteObject",
        "s3:ListBucket"
      ],
      "Resource": [
        "arn:aws:s3:::your-bucket-name",
        "arn:aws:s3:::your-bucket-name/*"
      ]
    }
  ]
}'

4. Generate Credentials

Create access key and secret key for the user:

aws iam create-access-key --user-name s3-sync-user

You'll get credentials like this:

{
    "AccessKey": {
        "UserName": "s3-sync-user",
        "AccessKeyId": "your-access-key-id",
        "Status": "Active",
        "SecretAccessKey": "your-secret-access-key",
        "CreateDate": "2025-07-21T08:39:23+00:00"
    }
}

Obsidian Setup

You need to configure each device (PC/smartphone) you want to sync.

1. Enable Community Plugins and Install Remotely Save

Go to Preferences → Community Plugins → Browse

2. Enable Remotely Save

3. Configure Remotely Save

The endpoint and region must match your bucket's region:

Choose A Remote Service: S3 or compatible

Endpoint: s3.ap-northeast-1.amazonaws.com

Region: ap-northeast-1

Access Key ID: Your obtained Access Key ID

Secret Access Key: Your obtained Secret Access Key

Bucket Name: Your created bucket name

S3 URL style: Path-style

Other settings are personal preferences.

4. Test Connection

Click "Check Connectivity" to verify the connection works.
If successful, no need to save manually - just close the window to exit settings.
Once complete, you'll see a new Sync icon on the left sidebar. Click it to test actual syncing.

5. Configure Other Devices

For cross-device sync, apply the same configuration on your smartphone/other PCs to enable syncing.

Summary

This article explained how to use AWS IAM to generate credentials and sync with an S3 bucket using Obsidian's Remotely Save plugin.

How to Persist Tool Permissions in Amazon Q Developer CLI

Xinzhi Sherry Zhu — Sun, 31 Aug 2025 05:00:22 +0000

This is the English translation of my Japanese article: https://zenn.dev/arvehisa/articles/amazon-q-dev-cli-permission-session-persistence

Background

When using Amazon Q Developer CLI, permission requests appear every time tools are called, interrupting the workflow. Even after granting permission multiple times in the same project, the requests reappear when the session changes, making it tedious to repeat the same actions repeatedly.

This article explains the types of tool permission settings in Q Developer CLI and how to persist them across sessions.
Please note that this information is as of August 2025, as this tool evolves very rapidly.

Types of Permission Settings

While I wanted to configure tool permissions across sessions, I also investigated within-session settings.

Permission Settings Within Sessions

1. Setting with Slash Commands

After starting a session with the q command, you can set permissions using slash commands:

# Allow specific tools
/tools trust @mcp_name/tool_name

# Allow all tools
/tools trust-all

2. Setting with Command Arguments

You can specify permissions with arguments when starting a session:

# Allow specific tools
q chat --trust-tools @mcp_name/tool_name

# Allow all tools
q chat --trust-all-tools

Issues with Within-Session Settings

Settings must be configured every time a new session starts
Individual specification is cumbersome when there are many MCP tools
trust-all is dangerous

Persistence Across Sessions

Solution with Custom Agents

While persisting tool permissions across sessions was previously impossible, it became possible with the Custom Agents feature released on July 31, 2025.
Custom Agents are originally designed as agents for specific tasks or as Sub Agents called from the Main Agent, but they can also be used as a means to persist permissions.

https://aws.amazon.com/about-aws/whats-new/2025/07/amazon-q-developer-cli-custom-agents/
https://aws.amazon.com/jp/blogs/news/overcome-development-disarray-with-amazon-q-developer-cli-custom-agents/

Creating Configuration Files

Create a configuration file in the .amazonq/cli-agents/ directory:

{
  "$schema": "https://raw.githubusercontent.com/aws/amazon-q-developer-cli/refs/heads/main/schemas/agent-v1.json",
  "name": "your-custom-agent",
  "description": "your-agent-description",
  "prompt": "your-custom-agent-prompt",
  "tools": ["*"],
  "allowedTools": [
    "@filesystem/read_file",
    "@filesystem/write_file"
  ],
  "resources": [
    "file://README.md",
    "file://.amazonq/rules/**/*.md"
  ],
  "useLegacyMcpJson": true
}

Starting the Agent

Start the agent by specifying the created agent:

q chat --agent your-custom-agent

The permissions for the specified tools are then available in the ready state.

Thoughts

With Claude Code, you can adjust permissions in various ways, such as persisting them as project-specific settings in settings.json. For Q CLI, it's not currently that flexible, and the design philosophy seems to prioritize security and simplicity.

Also, the fact that Custom Agents can persist permissions might be because they are entities used by the Main Agent, and constantly asking users for permissions would significantly impair autonomy.

Summary

Within sessions: Temporarily set with --trust-tools or /tools trust
Across sessions: Persist permissions with Custom Agents

This approach allows for more efficient workflows while maintaining the security-focused design of Amazon Q Developer CLI.

Forem: Xinzhi Sherry Zhu

Notes on S3 Presigned URL Expiration

Introduction

Presigned URL

S3 Presigned URL Expiration

About the Expiration Time Specified During Issuance

How to Issue via Console

How to Issue via CLI

Credential Expiration Time

Summary

How to Set Up Remote MCP on Claude iOS/Android Mobile Apps

Remote MCP Now Available on Claude Mobile Apps

Setup Process

Mobile App Limitations

Side Note

Hosting Remote MCP Server on AWS Lambda for Free

Background

Why Lambda?

Serverless and Event-Driven

Individual Use Cases Fit Within the Free Tier

Libraries Used

Local vs Remote Architecture

Different Communication Methods

Why Use mcp_lambda_handler?

Different Roles from FastMCP

Data Flow Comparison

Local MCP Case

Remote MCP Case

Why Not Use FastMCP's Remote MCP Support Directly?

Implementation Example

Important Notes

Deployment and Operations

Setup Tasks

Conclusion

Related Previous Articles

Building a Local Memory MCP for Claude Desktop - A Journey of AI Memory

Introduction

What I Can Do Now

When I asked why I created this Local Memory MCP

When I asked about understanding AWS's new AgentCore service

Why I Built This

I Wanted Claude to Maintain Personal Context

I Wanted Control Over Memory Extraction and Storage

Custom Extraction

Local Storage

MCP Enables Client Versatility

Implementation

Code Overview

Setup

1. Project Creation

2. Install Dependencies

3. Register with Claude Desktop

4. Restart Claude Desktop

5. Test Functionality

How It Works

MCP Operation Flow

1. Initialization Flow

2. Memory Creation Flow (Tool Execution Example)

3. Memory Reference Flow

Component Roles

This Memory MCP's Mechanism

What Moved Me About Using This

1. Beauty of Simple CRUD Operations and LLM Intelligence Exceeding Expectations

2. Collaborative Development Process with User (LLM)

3. Claude Remembered Me

Bonus: Obsidian Integration

Conclusion

Using Claude Sonnet 4's 1M Context Window on Amazon Bedrock

Important Notes

Python SDK (Boto3) + Converse API Sample Code

TypeScript SDK + Converse API Sample Code

TypeScript SDK + InvokeModel Sample Code

Example Execution Results

Troubleshooting

Summary

Sync Obsidian via S3 with Remotely Save Plugin

Overview

Plugin Used: Remotely Save

Process Overview

AWS Setup

Why Use `mcp_lambda_handler`?