What can you do with the AWS Lambda integration?

LiveContext exposes 41 operations on AWS Lambda, covering function, alias, event source mapping and function url. Common uses include Remove outdated tags, Inspect layer contents and Clean up unused aliases.

LiveContext

All integrations

AWS Lambda integration

AWS serverless compute service API for managing and invoking Lambda functions. Create, update, and invoke functions, manage layers, aliases, event source mappings, and function configurations.

41 toolsCustom authAPI docs

Connect AWS Lambda How integrations work

Common AWS Lambda use cases

Remove outdated tags
Inspect layer contents
Clean up unused aliases
View deployment aliases
View deployment history
Check concurrency limits
Find shared dependencies
Clean up unused functions
Audit exposed function URLs
Clean up old layer versions

What you can do with AWS Lambda

Each of these is one operation on one endpoint, available both as a workflow step and as a tool an AI agent can call on its own. Nothing bundles several operations into one action, so what a run did stays readable afterwards.

Most endpoints run on the free plan. A few, mainly the ones that publish on your behalf, need a paid plan.

Function, 8 operations

POSTcreate_function
Creates a new Lambda function with the specified code, runtime, and configuration.
DELETEdelete_function
Deletes a Lambda function and optionally a specific version.
GETget_function
Retrieves detailed configuration and code metadata for a specific Lambda function.
POSTinvoke_function
Invokes a Lambda function synchronously or asynchronously with an optional JSON payload.
POSTinvoke_with_response_stream
Invokes a Lambda function with response streaming, receiving chunked output up to 200 MB.
GETlist_functions
Lists all Lambda functions in the AWS account with optional filtering and pagination.
PUTupdate_function_code
Updates the deployment code of an existing Lambda function.
PUTupdate_function_configuration
Updates the configuration settings of an existing Lambda function.

Alias, 5 operations

POSTcreate_alias
Creates a named alias pointing to a specific Lambda function version.
DELETEdelete_alias
Deletes a Lambda function alias without affecting the underlying version.
GETget_alias
Retrieves details of a specific Lambda function alias.
GETlist_aliases
Lists all aliases for a Lambda function with optional version filtering.
PUTupdate_alias
Updates a Lambda function alias to point to a different version or modify routing.

Event source mapping, 5 operations

POSTcreate_event_source_mapping
Creates an event source mapping to trigger a Lambda function from a queue or stream.
DELETEdelete_event_source_mapping
Deletes an event source mapping to stop a Lambda function from receiving events.
GETget_event_source_mapping
Retrieves details of a specific event source mapping by UUID.
GETlist_event_source_mappings
Lists event source mappings that trigger Lambda functions from queues and streams.
PUTupdate_event_source_mapping
Updates the configuration of an existing event source mapping.

Function url, 5 operations

POSTcreate_function_url_config
Creates a dedicated HTTPS Function URL endpoint that invokes a Lambda function directly.
DELETEdelete_function_url_config
Deletes the Function URL configuration for a Lambda function.
GETget_function_url_config
Retrieves the Function URL configuration for a Lambda function.
GETlist_function_url_configs
Lists all Function URL configurations for a Lambda function.
PUTupdate_function_url_config
Updates an existing Function URL configuration.

Layer, 4 operations

DELETEdelete_layer_version
Deletes a specific version of a Lambda layer.
GETget_layer_version
Retrieves details of a specific Lambda layer version.
GETlist_layers
Lists Lambda layers available in the account with optional runtime and architecture filters.
POSTpublish_layer_version
Publishes a new version of a Lambda layer with shared code or data.

Provisioned concurrency, 4 operations

DELETEdelete_provisioned_concurrency_config
Removes provisioned concurrency from an alias or version, releasing pre-warmed environments.
GETget_provisioned_concurrency_config
Retrieves the provisioned concurrency configuration for an alias or version.
GETlist_provisioned_concurrency_configs
Lists provisioned concurrency configurations for a function across aliases and versions.
PUTput_provisioned_concurrency_config
Allocates provisioned concurrency to pre-warm a Lambda alias or version.

Concurrency, 3 operations

DELETEdelete_function_concurrency
Removes reserved concurrency from a Lambda function, releasing it back to the account pool.
GETget_function_concurrency
Retrieves the reserved concurrency setting for a Lambda function.
PUTput_function_concurrency
Sets reserved concurrency for a Lambda function to guarantee and limit concurrent executions.

Tag, 3 operations

GETlist_tags
Lists all tags associated with a Lambda resource by ARN.
POSTtag_resource
Adds key-value tags to a Lambda resource for cost allocation and organization.
DELETEuntag_resource
Removes one or more tags from a Lambda resource by tag key.

Version, 2 operations

GETlist_versions
Lists all published versions of a Lambda function.
POSTpublish_version
Publishes a new immutable version from the current $LATEST function code and configuration.

Account, 1 operation

GETget_account_settings
Retrieves Lambda account-level settings including limits and usage.

Permission, 1 operation

POSTadd_permission
Adds a resource-based policy statement to grant invoke permissions on a Lambda function.

AWS Lambda API rate limits

15 requests per second

Verified May 2026 from https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#api-requests. 15 RPS across all control-plane APIs (not per-API), cannot be increased. Exceptions: GetFunction=100 RPS, GetPolicy=15 RPS. Invoke is gated by concurrency, not a fixed TPS: each execution environment serves up to 10 RPS sync; total = 10 * account concurrency (default 1000).

These are the limits AWS Lambda documents, not ones LiveContext measured. They can change and often depend on your plan, so check the AWS Lambda documentation for current values.

Use AWS Lambda from Claude Code, Cursor or Codex

Connect AWS Lambda in LiveContext, create an API key in Settings, then add the LiveContext MCP server to your client. Its AWS Lambda operations become tools the client can call, next to every other integration you connected.

Claude Code

claude mcp add --transport http livecontext https://livecontext.ai/mcp --header "X-API-Key: YOUR_API_KEY"

Codex (~/.codex/config.toml)

[mcp_servers.livecontext]
url = "https://livecontext.ai/mcp"

[mcp_servers.livecontext.http_headers]
"X-API-Key" = "YOUR_API_KEY"

Cursor, Claude Desktop and other JSON configs

{
  "mcpServers": {
    "livecontext": {
      "type": "http",
      "url": "https://livecontext.ai/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      }
    }
  }
}

Set up the MCP server step by step

How to connect AWS Lambda

Create your workspace
Sign up free. Nothing to install.
Connect AWS Lambda once
Add your AWS Lambda connection in Settings. Every tool from this integration reuses it, and secrets are encrypted at rest and visible only to you.
Describe the job in chat
The workflow builds itself in front of you and picks the endpoints it needs. Drag the steps yourself on the canvas whenever you would rather be explicit.

AWS Lambda integration FAQ

What can you do with the AWS Lambda integration?: LiveContext exposes 41 operations on AWS Lambda, covering function, alias, event source mapping and function url. Common uses include Remove outdated tags, Inspect layer contents and Clean up unused aliases.
What are the AWS Lambda API rate limits?: AWS Lambda documents 15 requests per second. Verified May 2026 from https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#api-requests. 15 RPS across all control-plane APIs (not per-API), cannot be increased. Exceptions: GetFunction=100 RPS, GetPolicy=15 RPS. Invoke is gated by concurrency, not a fixed TPS: each execution environment serves up to 10 RPS sync; total = 10 * account concurrency (default 1000). Limits are set by AWS Lambda and can depend on your plan.