Idempotency

Idempotency refers to the property that performing the same operation once and performing it multiple times produce exactly the same result, and is a key design principle for ensuring data consistency in distributed systems.

Idempotency is a key principle in distributed systems design, meaning that executing the same operation once and executing it multiple times produce exactly the same result.

In the HTTP protocol specification, GET, PUT, and DELETE are defined as idempotent methods, while POST is not.

Idempotency refers to the property whereby executing the same operation once produces exactly the same effect as executing it multiple times, with HTTP PUT/DELETE methods and database INSERT OR IGNORE semantics being typical examples

Common methods for achieving idempotency include assigning a unique request ID (idempotency key) to each write operation, or using conditional writes (compare-and-swap) that only execute when the target data is in the expected state.

Idempotency means that the same operation should yield the same final result regardless of whether it is executed once or multiple times; a common implementation is to generate a globally unique request ID (such as a UUID) for each request for server-side deduplication.

LangGraph has built-in checkpointing support for state persistence, allowing an Agent to resume from a breakpoint after interruption.

防止重复扣费的幂等性实现方案包括数据库唯一约束、状态机检查、Redis分布式锁和乐观锁版本号

GET, PUT, and DELETE are all idempotent operations, whereas POST is non-idempotent.

POST 是非幂等写入，超时后重试可能导致重复创建（如创建两个订单），需要幂等键或避免重试。

Saving a checkpoint does not automatically make external side effects safe to retry; if the agent had already initiated a refund through a payment API before crashing, replaying from the checkpoint could result in a duplicate refund.

Design an idempotency key for each automated action (such as ticket ID + operation type), so that the system checks whether the operation has already been completed before retrying, which can avoid duplicate tickets, duplicate charges, or duplicate emails when retries are triggered by network jitter or API rate limiting.

A common way to implement webhook idempotency is to deduplicate using the event ID (such as Stripe's event.id) as the unique key when persistently enqueuing, or to use an "query first, then write" optimistic lock at the business layer.

Because the sender keeps retrying when it does not receive a 2xx, a webhook endpoint may receive the same event multiple times, so the processing logic must implement idempotency.

The wake request is idempotent: executing it once has the same result as executing it multiple times, merely keeping the container awake without producing side effects, so this endpoint can safely be exposed without authentication.

Financial idempotency must be anchored in the persistent storage layer, implemented through a unique constraint on transaction metadata, rather than in an application-layer Redis cache, because Redis keys may be evicted, the cluster may fail over, and the in-memory cache may be cleared during deployment.

Implementing idempotency in a pure Python pipeline requires each function to either be a pure function (with no side effects) or to explicitly isolate its side effects and attach a unique identifier.

The prerequisite for a single step to be retryable is that the step is idempotent, that is, repeated execution with the same input does not produce accumulated side effects.

Blindly retrying non-idempotent operations (such as payments, placing orders, creating tasks, sending messages) may cause duplicate charges or duplicate side effects, and is a classic anti-pattern in distributed systems.

For creation-type endpoints, if the endpoint is not idempotent, retrying due to a timeout will create two tasks, resulting in duplicate charges