LangChain Reference

https://reference.langchain.com/
Admin
Unified API reference documentation for LangChain, LangGraph, Deep Agents, LangSmith, and...
Tokens:2,864,131
Snippets:28,342
Trust Score:9.5
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Import and embedding setup example

Source: https://reference.langchain.com/python/langchain-aws/vectorstores/inmemorydb/base/InMemoryVectorStore/from_texts

Example usage showing how to import InMemoryVectorStore and instantiate OpenAIEmbeddings. This is a partial example from the documentation.

```python
from langchain_aws.vectorstores import InMemoryVectorStore
                embeddings = OpenAIEmbeddings()
```

--------------------------------

### Install langchain-groq and set GROQ_API_KEY

Source: https://reference.langchain.com/python/langchain-groq/chat_models/ChatGroq

Install the langchain-groq package and set the GROQ_API_KEY environment variable as required setup.

```bash
pip install -U langchain-groq
export GROQ_API_KEY="your-api-key"
```

--------------------------------

### Install langchain-ollama and Setup Ollama Server

Source: https://reference.langchain.com/python/langchain-ollama/llms/OllamaLLM

Installs the langchain-ollama package and provides instructions for setting up the Ollama server.

```bash
pip install -U langchain-ollama
# Visit https://ollama.com/download to download and install Ollama
# (Linux users): start the server with `ollama serve`
```

--------------------------------

### Setup: Install langchain-ollama and pull a model

Source: https://reference.langchain.com/python/langchain-ollama/chat_models/ChatOllama

Install the langchain-ollama package and download a model from Ollama before using the ChatOllama integration.

```bash
ollama pull gpt-oss:20b
pip install -U langchain-ollama
```

--------------------------------

### setup()

Source: https://reference.langchain.com/python/langgraph.checkpoint.postgres/shallow/AsyncShallowPostgresSaver/setup

Documentation for the setup method of AsyncShallowPostgresSaver.

```APIDOC
## setup()

### Description
Sets up the checkpoint database asynchronously. This method creates the necessary tables in the Postgres database if they don't already exist and runs database migrations. It MUST be called directly by the user the first time the checkpointer is used.

### Method
setup

### Signature
```python
setup(
    self,
) -> None
```

### Parameters
None

### Returns
None

### Usage Notes
- Must be called before using the checkpointer for the first time.
- Creates tables and runs migrations asynchronously.
```

--------------------------------

### Example: Compose SummarizationToolMiddleware with SummarizationMiddleware

Source: https://reference.langchain.com/python/deepagents/middleware/summarization/SummarizationToolMiddleware

Complete setup for using the summarization tool middleware with a SummarizationMiddleware instance announced by the 'Example' section. Compose both middlewares in the order shown and pass them to create_deep_agent.

```python
from deepagents.middleware.summarization import (
    SummarizationMiddleware,
    SummarizationToolMiddleware,
)

summ = SummarizationMiddleware(model="gpt-5.5", backend=backend)
tool_mw = SummarizationToolMiddleware(summ)

agent = create_deep_agent(middleware=[summ, tool_mw])
```

--------------------------------

### PostgresStore setup with from_conn_string helper

Source: https://reference.langchain.com/python/langgraph.store.postgres/base/PostgresStore

Convenient setup using the from_conn_string helper, which manages the connection lifecycle. Calls setup() once to run migrations.

```python
from langgraph.store.postgres import PostgresStore

conn_string = "postgresql://user:pass@localhost:5432/dbname"

with PostgresStore.from_conn_string(conn_string) as store:
    store.setup()

    # Store and retrieve data
    store.put(("users", "123"), "prefs", {"theme": "dark"})
    item = store.get(("users", "123"), "prefs")
```

--------------------------------

### AsyncPromptCache usage example

Source: https://reference.langchain.com/python/langsmith/prompt_cache/AsyncPromptCache

Example of using AsyncPromptCache with an async fetch function, setting and getting a cached prompt, and starting/stopping the cache.

```python
>>> async def fetch_prompt(key: str) -> PromptCommit:
...     return await client._afetch_prompt_from_api(key)
>>> cache = AsyncPromptCache(
...     max_size=100,
...     ttl_seconds=3600,
...     fetch_func=fetch_prompt,
... )
>>> await cache.start()
>>> cache.set("my-prompt:latest", prompt_commit)
>>> cached = cache.get("my-prompt:latest")
>>> await cache.stop()
```

--------------------------------

### create_examples

Source: https://reference.langchain.com/python/langsmith/client/Client/create_examples

Creates examples in a dataset. Supports both new-style `examples` argument and legacy keyword arguments.

```APIDOC
## [POST] /create_examples

### Description
Creates examples in a dataset. This method allows you to add multiple examples to a specified dataset, either by providing a list of example objects or using legacy keyword arguments.

### Method
POST

### Endpoint
`/create_examples`

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **dataset_name** (string) - Optional - The name of the dataset to create examples in. Must specify exactly one of `dataset_name` or `dataset_id`.
- **dataset_id** (string) - Optional - The ID of the dataset to create examples in. Must specify exactly one of `dataset_name` or `dataset_id`.
- **examples** (array) - Optional - A list of example objects, each containing `inputs`, `outputs`, `metadata`, `attachments`, etc.
- **dangerously_allow_filesystem** (boolean) - Optional - Whether to allow uploading files from the filesystem. Defaults to `false`.
- **max_concurrency** (integer) - Optional - Maximum concurrency for the operation. Must be between 1 and 3. Defaults to 1.
- **kwargs** (object) - Optional - Legacy keyword arguments, such as `inputs`, `outputs`, `metadata`, `splits`, `source_run_ids`, and `ids`.

### Request Example
```json
{
  "dataset_name": "agent-qa",
  "examples": [
    {
      "inputs": {"question": "what's an agent"},
      "outputs": {"answer": "an agent is..."},
      "metadata": {"difficulty": "easy"}
    },
    {
      "inputs": {"question": "can you explain the agent architecture in this diagram?"},
      "outputs": {"answer": "this diagram shows..."},
      "attachments": {"diagram": {"mime_type": "image/png", "data": "..."}},
      "metadata": {"difficulty": "medium"}
    }
  ]
}
```

### Response
#### Success Response (200)
- **count** (integer) - The number of examples created.
- **example_ids** (array) - The IDs of the created examples.

#### Response Example
```json
{
  "count": 2,
  "example_ids": ["uuid1", "uuid2"]
}
```

```

--------------------------------

### Example usage of PromptCache

Source: https://reference.langchain.com/python/langsmith/prompt_cache/PromptCache

Demonstrates creating a PromptCache with a fetch function, setting and getting a cache entry, and shutting down the cache.

```python
>>> def fetch_prompt(key: str) -> PromptCommit:
...     return client._fetch_prompt_from_api(key)
>>> cache = PromptCache(
...     max_size=100,
...     ttl_seconds=3600,
...     fetch_func=fetch_prompt,
... )
>>> cache.set("my-prompt:latest", prompt_commit)
>>> cached = cache.get("my-prompt:latest")
>>> cache.shutdown()
```

--------------------------------

### AsyncClient.list_examples()

Source: https://reference.langchain.com/python/langsmith/async_client/AsyncClient

Method to list examples from a dataset.

```APIDOC
## AsyncClient.list_examples

### Description
Lists examples from a dataset.

### Method
list_examples()

### Parameters
Not specified in source.

### Response
Returns a list of examples.
```

--------------------------------

### Create examples with attachments

Source: https://reference.langchain.com/python/langsmith/client/Client/create_examples

Example usage of create_examples with a dataset and a list of examples, including one with an attachment. The response contains 'example_ids'.

```python
from langsmith import Client

client = Client()

dataset = client.create_dataset("agent-qa")

examples = [
    {
        "inputs": {"question": "what's an agent"},
        "outputs": {"answer": "an agent is..."},
        "metadata": {"difficulty": "easy"},
    },
    {
        "inputs": {
            "question": "can you explain the agent architecture in this diagram?"
        },
        "outputs": {"answer": "this diagram shows..."},
        "attachments": {"diagram": {"mime_type": "image/png", "data": b"..."}},
        "metadata": {"difficulty": "medium"},
    },
    # more examples...
]

response = client.create_examples(dataset_name="agent-qa", examples=examples)
# -> {"example_ids": [...
```

--------------------------------

### start

Source: https://reference.langchain.com/python/langsmith/sandbox/_async_sandbox/AsyncSandbox/start

Starts a stopped sandbox and waits until it is ready. The sandbox's status and dataplane_url are updated in place after starting.

```APIDOC
## start

### Description
Start a stopped sandbox and wait until ready. After starting, the sandbox's status and dataplane_url are updated in place.

### Method
start

### Signature
```python
start(
    self,
    *,
    timeout: int = 120,
    headers: RequestHeaders = None,
) -> None
```

### Parameters
- **timeout** (int) - Optional - Timeout in seconds when waiting for ready. (default: `120`)
- **headers** (RequestHeaders) - Optional - Optional per-request header overrides. (default: `None`)

### Returns
None
```

--------------------------------

### Get assistant by ID example

Source: https://reference.langchain.com/python/langgraph-sdk/_async/assistants/AssistantsClient/get

Example usage of the get method to retrieve an assistant by ID and print the result.

```python
assistant = await client.assistants.get(
    assistant_id="my_assistant_id"
)
print(assistant)
```

--------------------------------

### setup()

Source: https://reference.langchain.com/python/langgraph.checkpoint.postgres/aio/AsyncPostgresSaver/setup

Documentation for the setup method of AsyncPostgresSaver, which initializes the checkpoint database.

```APIDOC
## setup()

### Description
Sets up the checkpoint database asynchronously. This method creates the necessary tables in the Postgres database if they don't already exist and runs database migrations. It MUST be called directly by the user the first time the checkpointer is used.

### Method
setup

### Signature
```python
setup(
    self,
) -> None
```

### Parameters
None

### Returns
None

### Usage Notes
- This method must be called before using the checkpointer for the first time.
- It is asynchronous and should be awaited.
```

--------------------------------

### Using Sandbox with context manager

Source: https://reference.langchain.com/python/langsmith/sandbox/_sandbox/Sandbox

Example usage of the Sandbox class obtained from SandboxClient.sandbox(). Uses the context manager protocol for automatic cleanup and runs a command to get Python version.

```python
with client.sandbox(snapshot_id="<snapshot-uuid>") as sandbox:
    result = sandbox.run("python --version")
    print(result.stdout)
```

--------------------------------

### Basic ChatAnthropic instantiation

Source: https://reference.langchain.com/python/langchain-anthropic/chat_models/ChatAnthropic

Basic setup for using ChatAnthropic. Requires installing the langchain-anthropic package and setting the ANTHROPIC_API_KEY environment variable. The example shows how to instantiate the model with a specific model name and comments for optional parameters.

```python
# pip install -U langchain-anthropic
# export ANTHROPIC_API_KEY="your-api-key"

from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(
    model="claude-sonnet-4-5-20250929",
    # temperature=,
    # max_tokens=,
    # timeout=,
    # max_retries=,
    # base_url="...",
    # Refer to API reference for full list of parameters
)
```

--------------------------------

### setup()

Source: https://reference.langchain.com/python/langgraph.store.postgres/base/PostgresStore

Initializes the database schema for the store.

```APIDOC
## setup()

### Description
Runs migrations to create necessary tables and indexes. Must be called before first use.

### Method
`setup`

### Example
```python
store.setup() # Run migrations. Done once
```
```

--------------------------------

### AsyncClient.read_example()

Source: https://reference.langchain.com/python/langsmith/async_client/AsyncClient

Method to read an example from a dataset.

```APIDOC
## AsyncClient.read_example

### Description
Reads an example from a dataset.

### Method
read_example()

### Parameters
Not specified in source.

### Response
Returns the example data.
```

--------------------------------

### Example usage of get

Source: https://reference.langchain.com/python/langgraph-sdk/_async/runs/RunsClient/get

Example showing how to use the `get` method with a client obtained from `get_client`. It retrieves a run by specifying the thread ID and run ID.

```python
client = get_client(url="http://localhost:2024")
run = await client.runs.get(
    thread_id="thread_id_to_delete",
    run_id="run_id_to_delete",
)
```

--------------------------------

### Example.__init__

Source: https://reference.langchain.com/python/langsmith/schemas/Example

Constructs a new Example instance. Accepts optional host URL and tenant ID parameters, along with additional keyword arguments.

```APIDOC
## Example.__init__

### Description
Constructs a new Example instance. Accepts optional host URL and tenant ID parameters, along with additional keyword arguments.

### Signature
```python
__init__(
    self,
    _host_url: Optional[str] = None,
    _tenant_id: Optional[UUID] = None,
    **kwargs: Any = {},
) -> None
```

### Parameters
- `_host_url` (Optional[str]) - Optional - The host URL.
- `_tenant_id` (Optional[UUID]) - Optional - The tenant ID.
- `**kwargs` (Any) - Optional - Additional keyword arguments.

### Returns
None
```

--------------------------------

### Example output of get

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/threads/SyncThreadsClient/get

Example output from the `get` method, showing the structure of the returned thread object. The output includes the thread ID, creation and update timestamps, and metadata.

```shell
-----------------------------------------------------

{
    'thread_id': 'my_thread_id',
    'created_at': '2024-07-18T18:35:15.540834+00:00',
    'updated_at': '2024-07-18T18:35:15.540834+00:00',
    'metadata': {'graph_id': 'agent'}
}
```

--------------------------------

### setup()

Source: https://reference.langchain.com/python/langgraph.store.postgres/base/PostgresStore/setup

Documentation for the setup method of PostgresStore, which initializes the database schema and runs migrations.

```APIDOC
## setup()

### Description
Sets up the store database by creating necessary tables and running migrations. Must be called directly by the user the first time the store is used.

### Method
setup

### Signature
```python
setup(
    self,
) -> None
```

### Parameters
None

### Returns
None

### Usage Notes
- This method MUST be called directly by the user the first time the store is used.
- It creates necessary tables in the Postgres database if they don't already exist and runs database migrations.
```

--------------------------------

### Example usage of configure_global_prompt_cache

Source: https://reference.langchain.com/python/langsmith/prompt_cache/configure_global_prompt_cache

Example showing how to import and call the function with custom max_size and ttl_seconds values.

```python
>>> from langsmith import configure_global_prompt_cache
>>> configure_global_prompt_cache(max_size=200, ttl_seconds=7200)
```

--------------------------------

### AsyncBoxesResourceWithRawResponse.start

Source: https://reference.langchain.com/python/langsmith/utils

Starts a sandbox box asynchronously.

```APIDOC
## POST /boxes/{box_id}/start

### Description
Starts a sandbox box asynchronously.

### Method
POST

### Endpoint
/boxes/{box_id}/start

### Parameters
#### Path Parameters
- **box_id** (string) - Required - The unique identifier of the box.

### Response
#### Success Response (200)
- **status** (string) - The new box status.

#### Response Example
{
  "status": "running"
}
```

--------------------------------

### setup()

Source: https://reference.langchain.com/python/langgraph.store.postgres/aio/AsyncPostgresStore/setup

Sets up the store database asynchronously by creating necessary tables and running migrations. This method must be called directly by the user the first time the store is used.

```APIDOC
## setup()

### Description
Sets up the store database asynchronously. This method creates the necessary tables in the Postgres database if they don't already exist and runs database migrations. It MUST be called directly by the user the first time the store is used.

### Method
setup

### Signature
```python
setup(
    self,
) -> None
```

### Parameters
- **self** - The instance of the AsyncPostgresStore.

### Returns
- **None** - This method returns nothing.

### Usage Notes
- Must be called before any other store operations.
- Creates tables and runs migrations asynchronously.
```

--------------------------------

### Example usage of get

Source: https://reference.langchain.com/python/langgraph-sdk/_async/threads/ThreadsClient/get

Example usage of the get method. It creates a client, retrieves a thread by ID, and prints the thread object. The output shows the thread details including metadata.

```python
client = get_client(url="http://localhost:2024")
thread = await client.threads.get(
    thread_id="my_thread_id"
)
print(thread)
```

```shell
-----------------------------------------------------

{
    'thread_id': 'my_thread_id',
    'created_at': '2024-07-18T18:35:15.540834+00:00',
    'updated_at': '2024-07-18T18:35:15.540834+00:00',
    'metadata': {'graph_id': 'agent'}
}
```

--------------------------------

### Example: list_feedback_configs usage

Source: https://reference.langchain.com/python/langsmith/client/Client/list_feedback_configs

Example usage of list_feedback_configs to iterate over all feedback configurations and print each feedback key with its configuration.

```python
from langsmith import Client

client = Client()
for config in client.list_feedback_configs():
    print(f"{config.feedback_key}: {config.feedback_config}")
```

--------------------------------

### Install langchain-aws

Source: https://reference.langchain.com/python/langchain-aws/chat_models/bedrock_converse/ChatBedrockConverse

Install the LangChain integration for Amazon Bedrock after completing the AWS setup steps.

```bash
pip install -U langchain-aws
```

--------------------------------

### setup()

Source: https://reference.langchain.com/python/langgraph.checkpoint.postgres/PostgresSaver/setup

Sets up the checkpoint database asynchronously. Creates necessary tables and runs migrations. Must be called directly by the user the first time the checkpointer is used.

```APIDOC
## setup()

### Description
Sets up the checkpoint database asynchronously. This method creates the necessary tables in the Postgres database if they don't already exist and runs database migrations. It MUST be called directly by the user the first time the checkpointer is used.

### Method
setup

### Signature
```python
setup(
    self,
) -> None
```

### Parameters
None

### Returns
None

### Usage Notes
- Must be called before using the checkpointer for the first time.
- Asynchronous method.
```

--------------------------------

### examples

Source: https://reference.langchain.com/python/langsmith/schemas/PromptCommit/examples

The `examples` attribute is a list of dictionaries that holds example data associated with a prompt commit. It is part of the `PromptCommit` schema in the LangSmith Python SDK.

```APIDOC
## examples

### Description
The `examples` attribute is a list of dictionaries that holds example data associated with a prompt commit. It is part of the `PromptCommit` schema in the LangSmith Python SDK.

### Attribute
`examples`

### Type
`list[dict]`

### Example
```python
examples: list[dict]
```
```

--------------------------------

### SandboxTokenVerifier Usage Example

Source: https://reference.langchain.com/python/langsmith/sandbox/_verify/SandboxTokenVerifier

Example demonstrating how to verify user tokens and callback signatures using the verifier.

```python
verifier = SandboxTokenVerifier()

# In an app served from a LangSmith-login service URL:
user = verifier.verify_user_token(
    request.headers[USER_TOKEN_HEADER], audience=request.headers["Host"]
)

# In a proxy callback endpoint:
callback = verifier.verify_callback(
    body=await request.body(),
    signature=request.headers[CALLBACK_SIGNATURE_HEADER],
    aud="https://example.com/sandbox-callback",
)
```

--------------------------------

### Output of get assistant

Source: https://reference.langchain.com/python/langgraph-sdk/_async/assistants/AssistantsClient/get

Example output of the get method, showing the assistant object with its fields.

```shell
----------------------------------------------------

{
    'assistant_id': 'my_assistant_id',
    'graph_id': 'agent',
    'created_at': '2024-06-25T17:10:33.109781+00:00',
    'updated_at': '2024-06-25T17:10:33.109781+00:00',
    'config': {},
    'metadata': {'created_by': 'system'},
    'version': 1,
    'name': 'my_assistant'
}
```

--------------------------------

### Basic setup and usage of AsyncPostgresStore

Source: https://reference.langchain.com/python/langgraph.store.postgres/aio/AsyncPostgresStore

Shows how to create an AsyncPostgresStore from a connection string, run migrations with setup(), and store/retrieve data using aput() and aget().

```python
from langgraph.store.postgres import AsyncPostgresStore

conn_string = "postgresql://user:pass@localhost:5432/dbname"

async with AsyncPostgresStore.from_conn_string(conn_string) as store:
    await store.setup()  # Run migrations. Done once

    # Store and retrieve data
    await store.aput(("users", "123"), "prefs", {"theme": "dark"})
    item = await store.aget(("users", "123"), "prefs")
```

--------------------------------

### Example: Initialize SkillsMiddleware with FilesystemBackend

Source: https://reference.langchain.com/python/deepagents/middleware/skills/SkillsMiddleware

Example of creating a SkillsMiddleware instance with a FilesystemBackend and a list of sources, including tuple sources with labels to disambiguate leaf directories.

```python
from deepagents.backends.filesystem import FilesystemBackend

backend = FilesystemBackend(root_dir="/path/to/skills")
middleware = SkillsMiddleware(
    backend=backend,
    sources=[
        "/path/to/skills/user/",
        "/path/to/skills/project/",
        # Pass a (path, label) tuple to disambiguate sources whose
        # leaf directories would otherwise collide
        ("/home/me/.claude/skills", "User Claude"),
        ("/repo/.claude/skills", "Project Claude"),
    ],
)
```

--------------------------------

### BoxesResourceWithRawResponse.start

Source: https://reference.langchain.com/python/langsmith/utils

Starts a sandbox box.

```APIDOC
## POST /boxes/{box_id}/start

### Description
Starts a sandbox box.

### Method
POST

### Endpoint
/boxes/{box_id}/start

### Parameters
#### Path Parameters
- **box_id** (string) - Required - The unique identifier of the box.

### Response
#### Success Response (200)
- **status** (string) - The new box status.

#### Response Example
{
  "status": "running"
}
```

--------------------------------

### AsyncPostgresStore.setup

Source: https://reference.langchain.com/python/langgraph.store.postgres/aio/AsyncPostgresStore

Initializes the database schema for the store.

```APIDOC
## AsyncPostgresStore.setup

### Description
Runs migrations to create necessary tables and indexes. Must be called once before using the store.

### Usage Example
```python
async with AsyncPostgresStore.from_conn_string(conn_string) as store:
    await store.setup()  # Run migrations. Done once
```

### Notes
- This method is asynchronous and should be awaited.
- It is required before any other operations on the store.
```

--------------------------------

### list_examples

Source: https://reference.langchain.com/python/langsmith/async_client/AsyncClient/list_examples

Lists examples from a dataset, optionally filtered by dataset ID or name. Returns an asynchronous iterator of Example objects.

```APIDOC
## list_examples

### Description
List examples.

### Method
list_examples

### Signature
```python
list_examples(
    self,
    *,
    dataset_id: Optional[ls_client.ID_TYPE] = None,
    dataset_name: Optional[str] = None,
    **kwargs: Any = {},
) -> AsyncIterator[ls_schemas.Example]
```

### Parameters
#### Keyword Arguments
- **dataset_id** (Optional[ls_client.ID_TYPE]) - Optional - The ID of the dataset to list examples from.
- **dataset_name** (Optional[str]) - Optional - The name of the dataset to list examples from.
- **kwargs** (Any) - Optional - Additional keyword arguments.

### Returns
- **AsyncIterator[ls_schemas.Example]** - An asynchronous iterator of examples.
```

--------------------------------

### Update examples with langsmith Client

Source: https://reference.langchain.com/python/langsmith/client/Client/update_examples

Example usage of update_examples. It creates a dataset, creates examples, then updates them using the update_examples method with a list of updates. The response contains 'example_ids'.

```python
from langsmith import Client

client = Client()

dataset = client.create_dataset("agent-qa")

examples = [
    {
        "inputs": {"question": "what's an agent"},
        "outputs": {"answer": "an agent is..."},
        "metadata": {"difficulty": "easy"},
    },
    {
        "inputs": {
            "question": "can you explain the agent architecture in this diagram?"
        },
        "outputs": {"answer": "this diagram shows..."},
        "attachments": {"diagram": {"mime_type": "image/png", "data": b"..."}},
        "metadata": {"difficulty": "medium"},
    },
    # more examples...
]

response = client.create_examples(dataset_name="agent-qa", examples=examples)
example_ids = response["example_ids"]

updates = [
    {
        "id": example_ids[0],
        "inputs": {"question": "what isn't an agent"},
        "outputs": {"answer": "an agent is not..."},
    },
    {
        "id": example_ids[1],
        "attachments_operations": [
            {"rename": {"diagram": "agent_diagram"}, "retain": []}
        ],
    },
]
response = client.update_examples(dataset_name="agent-qa", updates=updates)
# -> {"example_ids": [...
```

--------------------------------

### create_llm_example

Source: https://reference.langchain.com/python/langsmith/client/Client/create_llm_example

This method adds an example (row) to an LLM-type dataset. It accepts a prompt, optional generation, dataset identifier (by ID or name), and an optional creation timestamp, returning the created example object.

```APIDOC
## create_llm_example

### Description
Adds an example (row) to an LLM-type dataset.

### Method
create_llm_example

### Signature
```python
create_llm_example(
    self,
    prompt: str,
    generation: Optional[str] = None,
    dataset_id: Optional[ID_TYPE] = None,
    dataset_name: Optional[str] = None,
    created_at: Optional[datetime.datetime] = None,
) -> ls_schemas.Example
```

### Parameters
- `prompt` (str) - Required - The input prompt for the example.
- `generation` (Optional[str]) - Optional - The output generation for the example. (default: `None`)
- `dataset_id` (Optional[Union[UUID, str]]) - Optional - The ID of the dataset. (default: `None`)
- `dataset_name` (Optional[str]) - Optional - The name of the dataset. (default: `None`)
- `created_at` (Optional[datetime.datetime]) - Optional - The creation timestamp of the example. (default: `None`)

### Returns
`ls_schemas.Example` - The created example
```

--------------------------------

### list_shared_examples

Source: https://reference.langchain.com/python/langsmith/client/Client/list_shared_examples

This method retrieves shared examples from a shared dataset using a share token or URL. It supports optional filtering by example IDs and a limit on the number of examples returned.

```APIDOC
## list_shared_examples

### Description
Get shared examples from a shared dataset using a share token or URL.

### Method
list_shared_examples

### Signature
```python
list_shared_examples(
    self,
    share_token: str,
    *,
    example_ids: Optional[list[ID_TYPE]] = None,
    limit: Optional[int] = None,
) -> Iterator[ls_schemas.Example]
```

### Parameters
- **share_token** (Union[UUID, str]) - Required - The share token or URL of the shared dataset.
- **example_ids** (Optional[List[UUID, str]]) - Optional - The IDs of the examples to filter by. (default: `None`)
- **limit** (Optional[int]) - Optional - Maximum number of examples to return, by default None. (default: `None`)

### Returns
`Iterator[ls_schemas.Example]` - List[ls_schemas.Example]: The list of shared examples.
```

--------------------------------

### from_examples

Source: https://reference.langchain.com/python/langchain-core/prompts/prompt/PromptTemplate/from_examples

Creates a PromptTemplate from a list of examples, with a prefix and suffix. This is intended to be used as a way to dynamically create a prompt from examples.

```APIDOC
## from_examples

### Description
Creates a PromptTemplate from a list of examples, with a prefix and suffix. This is intended to be used as a way to dynamically create a prompt from examples.

### Method
from_examples

### Signature
```python
from_examples(
    cls,
    examples: list[str],
    suffix: str,
    input_variables: list[str],
    example_separator: str = '\n\n',
    prefix: str = '',
    **kwargs: Any = {},
) -> PromptTemplate
```

### Parameters
- `examples` (list[str]) - Required - List of examples to use in the prompt.
- `suffix` (str) - Required - String to go after the list of examples. Should generally set up the user's input.
- `input_variables` (list[str]) - Required - A list of variable names the final prompt template will expect.
- `example_separator` (str) - Optional - The separator to use in between examples. (default: `'\n\n'`)
- `prefix` (str) - Optional - String that should go before any examples. Generally includes examples. (default: `''`)

### Returns
`PromptTemplate` - The final prompt generated.
```

--------------------------------

### Example Usage of create_neptune_sparql_qa_chain

Source: https://reference.langchain.com/python/langchain-aws/chains/graph_qa/neptune_sparql/create_neptune_sparql_qa_chain

Example usage of the create_neptune_sparql_qa_chain function. It creates a chain with an LLM and a graph, then invokes it with a query to get a response.

```python
chain = create_neptune_sparql_qa_chain(
    llm=llm,
    graph=graph
)
response = chain.invoke({"query": "your_query_here"})
```

--------------------------------

### Sandbox.start

Source: https://reference.langchain.com/python/langsmith/sandbox/_sandbox/Sandbox

Starts the sandbox if it is not already running.

```APIDOC
## Sandbox.start

### Description
Starts the sandbox if it is not already running.

### Method
start

### Returns
None
```

--------------------------------

### create_example_from_run

Source: https://reference.langchain.com/python/langsmith/client/Client/create_example_from_run

This method adds an example (row) to a dataset from a run. It accepts a run object and optionally a dataset ID, dataset name, and creation timestamp, and returns the created example.

```APIDOC
## create_example_from_run

### Description
Add an example (row) to a dataset from a run.

### Method
create_example_from_run

### Signature
```python
create_example_from_run(
    self,
    run: ls_schemas.Run,
    dataset_id: Optional[ID_TYPE] = None,
    dataset_name: Optional[str] = None,
    created_at: Optional[datetime.datetime] = None,
) -> ls_schemas.Example
```

### Parameters
- **run** (Run) - Required - The run to create an example from.
- **dataset_id** (Optional[Union[UUID, str]]) - Optional - The ID of the dataset. (default: `None`)
- **dataset_name** (Optional[str]) - Optional - The name of the dataset. (default: `None`)
- **created_at** (Optional[datetime.datetime]) - Optional - The creation timestamp of the example. (default: `None`)

### Returns
`ls_schemas.Example` - The created example
```

--------------------------------

### setup_logging()

Source: https://reference.langchain.com/python/langchain-aws/chat-models

Sets up logging for the library.

```APIDOC
## setup_logging()

### Description
Sets up logging for the library.

### Method
Function call

### Endpoint
`setup_logging()`

### Parameters
None

### Request Example
```python
setup_logging()
```

### Response
No return value.
```

--------------------------------

### create_examples()

Source: https://reference.langchain.com/python/langsmith/Client

Creates multiple examples.

```APIDOC
## create_examples()

### Description
Creates multiple examples.

### Method
POST

### Endpoint
/create_examples

### Parameters
None documented.

### Request Example
{}

### Response
#### Success Response (200)
No response schema documented.

#### Response Example
{}
```

--------------------------------

### init_embeddings usage examples

Source: https://reference.langchain.com/python/langchain/embeddings/base/init_embeddings

Example usage of init_embeddings with a model string, explicit provider, and additional parameters. Requires pip install langchain langchain-openai.

```python
# pip install langchain langchain-openai

# Using a model string
model = init_embeddings("openai:text-embedding-3-small")
model.embed_query("Hello, world!")

# Using explicit provider
model = init_embeddings(model="text-embedding-3-small", provider="openai")
model.embed_documents(["Hello, world!", "Goodbye, world!"])

# With additional parameters
model = init_embeddings("openai:text-embedding-3-small", api_key="sk-...")
```

--------------------------------

### Example: with_alisteners with async callbacks

Source: https://reference.langchain.com/python/langchain-core/runnables/base/Runnable/with_alisteners

Example usage of with_alisteners with async on_start and on_end callbacks. The callbacks run concurrently with the Runnable execution; on_start callbacks for both runs start before any Runnable starts, and on_end callbacks run after each Runnable finishes. The output shows the interleaved execution order.

```python
from langchain_core.runnables import RunnableLambda, Runnable
from datetime import datetime, timezone
import time
import asyncio

def format_t(timestamp: float) -> str:
    return datetime.fromtimestamp(timestamp, tz=timezone.utc).isoformat()

async def test_runnable(time_to_sleep: int):
    print(f"Runnable[{time_to_sleep}s]: starts at {format_t(time.time())}")
    await asyncio.sleep(time_to_sleep)
    print(f"Runnable[{time_to_sleep}s]: ends at {format_t(time.time())}")

async def fn_start(run_obj: Runnable):
    print(f"on start callback starts at {format_t(time.time())}")
    await asyncio.sleep(3)
    print(f"on start callback ends at {format_t(time.time())}")

async def fn_end(run_obj: Runnable):
    print(f"on end callback starts at {format_t(time.time())}")
    await asyncio.sleep(2)
    print(f"on end callback ends at {format_t(time.time())}")

runnable = RunnableLambda(test_runnable).with_alisteners(
    on_start=fn_start, on_end=fn_end
)

async def concurrent_runs():
    await asyncio.gather(runnable.ainvoke(2), runnable.ainvoke(3))

asyncio.run(concurrent_runs())
```

```python
# Result:
# on start callback starts at 2025-03-01T07:05:22.875378+00:00
# on start callback starts at 2025-03-01T07:05:22.875495+00:00
# on start callback ends at 2025-03-01T07:05:25.878862+00:00
# on start callback ends at 2025-03-01T07:05:25.878947+00:00
# Runnable[2s]: starts at 2025-03-01T07:05:25.879392+00:00
# Runnable[3s]: starts at 2025-03-01T07:05:25.879804+00:00
# Runnable[2s]: ends at 2025-03-01T07:05:27.881998+00:00
# on end callback starts at 2025-03-01T07:05:27.882360+00:00
# Runnable[3s]: ends at 2025-03-01T07:05:28.881737+00:00
# on end callback starts at 2025-03-01T07:05:28.882428+00:00
# on end callback ends at 2025-03-01T07:05:29.883893+00:00
# on end callback ends at 2025-03-01T07:05:30.884831+00:00
```

--------------------------------

### SkillsMiddleware Usage Example

Source: https://reference.langchain.com/python/deepagents/middleware/skills

Full usage example showing how to import and instantiate SkillsMiddleware with a backend and a list of sources. Sources are loaded in order, with later sources overriding earlier ones when skills have the same name.

```python
from deepagents.backends.state import StateBackend
from deepagents.middleware.skills import SkillsMiddleware

middleware = SkillsMiddleware(
    backend=my_backend,
    sources=[
        "/skills/base/",
        "/skills/user/",
        "/skills/project/",
        ("/repo/.claude/skills", "Project Claude"),
    ],
)
```

--------------------------------

### list_examples()

Source: https://reference.langchain.com/python/langsmith/Client

Lists examples.

```APIDOC
## list_examples()

### Description
Lists examples.

### Method
GET

### Endpoint
/list_examples

### Parameters
None documented.

### Request Example
{}

### Response
#### Success Response (200)
No response schema documented.

#### Response Example
{}
```

--------------------------------

### Awaiting run.output()

Source: https://reference.langchain.com/python/langgraph/stream/run_stream/AsyncGraphRunStream/output

Example of awaiting the output() method to get the final state.

```python
output = await run.output()
```

--------------------------------

### aselect_examples

Source: https://reference.langchain.com/python/langchain-core/example_selectors/length_based/LengthBasedExampleSelector/aselect_examples

Async select which examples to use based on the input lengths.

```APIDOC
## aselect_examples

### Description
Async select which examples to use based on the input lengths.

### Method
aselect_examples

### Signature
```python
aselect_examples(
    self,
    input_variables: dict[str, str],
) -> list[dict[str, Any]]
```

### Parameters
- **input_variables** (dict[str, str]) - Required - A dictionary with keys as input variables and values as their values.

### Returns
- **list[dict[str, Any]]** - A list of examples to include in the prompt.
```

--------------------------------

### Example: binding on_start and on_end listeners

Source: https://reference.langchain.com/python/langchain-core/runnables/base/Runnable/with_listeners

Example showing how to use with_listeners to bind on_start and on_end callbacks that print the run's start and end times.

```python
from langchain_core.runnables import RunnableLambda
from langchain_core.tracers.schemas import Run

import time

def test_runnable(time_to_sleep: int):
    time.sleep(time_to_sleep)

def fn_start(run_obj: Run):
    print("start_time:", run_obj.start_time)

def fn_end(run_obj: Run):
    print("end_time:", run_obj.end_time)

chain = RunnableLambda(test_runnable).with_listeners(
    on_start=fn_start, on_end=fn_end
)
chain.invoke(2)
```

--------------------------------

### create_example()

Source: https://reference.langchain.com/python/langsmith/Client

Creates a single example.

```APIDOC
## create_example()

### Description
Creates a single example.

### Method
POST

### Endpoint
/create_example

### Parameters
None documented.

### Request Example
{}

### Response
#### Success Response (200)
No response schema documented.

#### Response Example
{}
```

--------------------------------

### example_ids

Source: https://reference.langchain.com/python/langsmith/schemas/UpsertExamplesResponse/example_ids

The ids of the examples that were upserted.

```APIDOC
## example_ids

### Description
The ids of the examples that were upserted.

### Type
list[str]

### Signature
```python
example_ids: list[str]
```
```
Tokens:
Raw