> ## Documentation Index
> Fetch the complete documentation index at: https://docs.inquantum.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# OpenLLMetry Async Integration

> Log LLM traces directly to Planck, bypassing our proxy, with OpenLLMetry. Supports OpenAI, Anthropic, Azure OpenAI, Cohere, Bedrock, Google AI Platform, and more.

# Overview

Async Integration let's you log events and calls without placing Planck in your app's critical
path. This ensures that an issue with Planck will not cause an outage to your app.

<Tabs>
  <Tab title="Node.js">
    <Steps>
      <Step title="Install Planck Async">
        ```bash theme={null}
        npm install @inquantum/planck-async
        ```
      </Step>

      <Step title="Initialize Logger">
        ```typescript theme={null}
        import { PlanckAsyncLogger } from "@inquantum/planck-async";
        import OpenAI from "openai";

        const logger = new PlanckAsyncLogger({
          apiKey: process.env.PLANCK_API_KEY,
          // pass in the providers you want logged
          providers: {
            openAI: OpenAI,
            //anthropic: Anthropic,
            //cohere: Cohere
            // ...
          }
        });
        logger.init();

        const openai = new OpenAI();

        async function main() {
          const completion = await openai.chat.completions.create({
            messages: [
              {"role": "system", "content": "You are a helpful assistant."},
              {"role": "user", "content": "Who won the world series in 2020?"},
              {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
              {"role": "user", "content": "Where was it played?"}
            ],
            model: "gpt-4o-mini",
          });

          console.log(completion.choices[0]);
        }

        main();
        ```
      </Step>

      <Step title="Properties">
        You can set properties on the logger to be used in Planck using the `withProperties` method. (These can be used for [Sessions](/features/sessions), [User Metrics](/features/advanced-usage/user-metrics), and more.)

        ```typescript theme={null}
        const sessionId = randomUUID();

        logger.withProperties({
          "Planck-Session-Id": sessionId,
          "Planck-Session-Path": "/abstract",
          "Planck-Session-Name": "Course Plan",
        }, () => {
          const completion = await openai.chat.completions.create({
            // ...
          })
        })
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Python">
    <Steps>
      <Step title="Install Planck Async">
        ```bash theme={null}
        pip install planck-async
        ```
      </Step>

      <Step title="Initialize Logger">
        ```python theme={null}
        from planck_async import PlanckAsyncLogger
        from openai import OpenAI

        logger = PlanckAsyncLogger(
          api_key=PLANCK_API_KEY,
        )

        logger.init()

        client = OpenAI(api_key=OPENAI_API_KEY)

        # Make the OpenAI call
        response = client.chat.completions.create(
          model="gpt-4o-mini",
          messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "Who won the world series in 2020?"},
            {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
            {"role": "user", "content": "Where was it played?"}
          ]
        )

        print(response.choices[0])
        ```
      </Step>

      <Step title="Properties">
        You can set properties on the logger to be used in Planck using the `set_properties` method. (These can be used for [Sessions](/features/sessions), [User Metrics](/features/advanced-usage/user-metrics), and more.)

        ```python theme={null}
        session_id = str(uuid.uuid4())

        logger.set_properties({
          "Planck-Session-Id": session_id,
          "Planck-Session-Path": "/abstract",
          "Planck-Session-Name": "Course Plan",
        })

        response = client.chat.completions.create(
          # ...
        )
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

# Disabling Logging

You can completely disable all logging to Planck if needed when using the async integration mode. This is useful for development environments or when you want to temporarily stop sending data to Planck without changing your code structure.

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    # Disable all logging in async mode
    logger.disable_logging()

    # Later, re-enable logging if needed
    logger.enable_logging()
    ```
  </Tab>

  <Tab title="Node.js">
    Coming soon
  </Tab>
</Tabs>

When logging is disabled, no traces will be sent to Planck. This is different from `disable_content_tracing()` which only omits request and response content but still sends other metrics. Note that this feature is only available when using Planck's async integration mode.

# Supported Providers

* [x] OpenAI
* [x] Anthropic
* [x] Azure OpenAI
* [x] Cohere
* [x] Bedrock
* [x] Google AI Platform

# Other Integrations

* [Gateway Integration](/getting-started/integration-method/gateway)