LangChain Reference home pageLangChain ReferenceLangChain Reference
  • GitHub
  • Main Docs
Deep Agents
LangChain
LangGraph
Integrations
LangSmith
  • Overview
    • Overview
    • Caches
    • Callbacks
    • Documents
    • Document loaders
    • Embeddings
    • Exceptions
    • Language models
    • Serialization
    • Output parsers
    • Prompts
    • Rate limiters
    • Retrievers
    • Runnables
    • Utilities
    • Vector stores
    MCP Adapters
    Standard Tests
    Text Splitters
    ⌘I

    LangChain Assistant

    Ask a question to get started

    Enter to send•Shift+Enter new line

    Menu

    OverviewCachesCallbacksDocumentsDocument loadersEmbeddingsExceptionsLanguage modelsSerializationOutput parsersPromptsRate limitersRetrieversRunnablesUtilitiesVector stores
    MCP Adapters
    Standard Tests
    Text Splitters
    Language
    Theme
    Pythonlangchain-corerate_limitersInMemoryRateLimiter
    Class●Since v0.2

    InMemoryRateLimiter

    An in memory rate limiter based on a token bucket algorithm.

    This is an in memory rate limiter, so it cannot rate limit across different processes.

    The rate limiter only allows time-based rate limiting and does not take into account any information about the input or the output, so it cannot be used to rate limit based on the size of the request.

    It is thread safe and can be used in either a sync or async context.

    The in memory rate limiter is based on a token bucket. The bucket is filled with tokens at a given rate. Each request consumes a token. If there are not enough tokens in the bucket, the request is blocked until there are enough tokens.

    These tokens have nothing to do with LLM tokens. They are just a way to keep track of how many requests can be made at a given time.

    Current limitations:

    • The rate limiter is not designed to work across different processes. It is an in-memory rate limiter, but it is thread safe.
    • The rate limiter only supports time-based rate limiting. It does not take into account the size of the request or any other factors.
    Copy
    InMemoryRateLimiter(
      self,
      *,
      requests_per_second: float = 1,
      check_every_n_seconds: float = 0.1,
      max_bucket_size: float = 1
    )

    Bases

    BaseRateLimiter

    Example:

    import time
    
    from langchain_core.rate_limiters import InMemoryRateLimiter
    
    rate_limiter = InMemoryRateLimiter(
        requests_per_second=0.1,  # <-- Can only make a request once every 10 seconds!!
        check_every_n_seconds=0.1,  # Wake up every 100 ms to check whether allowed to make a request,
        max_bucket_size=10,  # Controls the maximum burst size.
    )
    
    from langchain_anthropic import ChatAnthropic
    
    model = ChatAnthropic(
        model_name="claude-sonnet-4-5-20250929", rate_limiter=rate_limiter
    )
    
    for _ in range(5):
        tic = time.time()
        model.invoke("hello")
        toc = time.time()
        print(toc - tic)

    Used in Docs

    • How to handle model rate limits
    • Run backtests on a new version of an agent
    • Langfair integrations

    Parameters

    NameTypeDescription
    requests_per_secondfloat
    Default:1

    The number of tokens to add per second to the bucket. The tokens represent "credit" that can be used to make requests.

    check_every_n_secondsfloat
    Default:0.1

    Check whether the tokens are available every this many seconds. Can be a float to represent fractions of a second.

    max_bucket_sizefloat
    Default:1

    The maximum number of tokens that can be in the bucket. Must be at least 1. Used to prevent bursts of requests.

    Constructors

    constructor
    __init__
    NameType
    requests_per_secondfloat
    check_every_n_secondsfloat
    max_bucket_sizefloat

    Attributes

    attribute
    requests_per_second: requests_per_second
    attribute
    available_tokens: float
    attribute
    max_bucket_size: max_bucket_size
    attribute
    last: float | None
    attribute
    check_every_n_seconds: check_every_n_seconds

    Methods

    method
    acquire

    Attempt to acquire a token from the rate limiter.

    This method blocks until the required tokens are available if blocking is set to True.

    If blocking is set to False, the method will immediately return the result of the attempt to acquire the tokens.

    method
    aacquire

    Attempt to acquire a token from the rate limiter. Async version.

    This method blocks until the required tokens are available if blocking is set to True.

    If blocking is set to False, the method will immediately return the result of the attempt to acquire the tokens.

    View source on GitHub