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

# Integrate via OpenAI library

If you've already started building your application using the OpenAI SDK but want to start experimenting with Langtail, you can configure your existing code to start sending requests to the OpenAI Proxy.

In this guide, we'll generate a Langtail API key, modify your existing code to send LLM requests via the proxy, and then use Langtail's observability tools to see the requests coming from your app.

Let's get started:

<Steps>
  <Step title="Prerequisites">
    Before moving on, make sure you have:

    * A Langtail account ([create one here](https://langtail.com/sign-up))
    * An OpenAI key already added to your Langtail workspace
  </Step>

  <Step title="Generate a project API key">
    <video controls className="w-full aspect-video" src="https://mintcdn.com/langtail-64/21vrq2LQuE9wZl3n/images/proxy/create-api-key.mp4?fit=max&auto=format&n=21vrq2LQuE9wZl3n&q=85&s=6497dbec595cba6e286a75f916a1c7d2" data-path="images/proxy/create-api-key.mp4" />

    1. In Langtail, open an existing project or create a new one.
    2. In the left sidebar, click *Secrets*.
    3. Click *New API Key*, optionally set a name and a budget limit, then click *Create*.
    4. Copy the key.
  </Step>

  <Step title="Modify your code to use the proxy">
    1. Add your Langtail project API key to an environment variable. In the following snippets, we use `LANGTAIL_API_KEY`.
    2. In your codebase, find where you initialize the OpenAI SDK and make these modifications:

    <Tabs>
      <Tab title="JavaScript">
        <AccordionGroup>
          <Accordion title="OpenAI SDK v4" defaultOpen>
            ```javascript theme={null}
            import OpenAI from "openai";

            // Add baseURL to send requests to Langtail instead of directly to OpenAI
            const openai = new OpenAI({
              apiKey: process.env.LANGTAIL_API_KEY,
              baseURL: "https://proxy.langtail.com/v1",
              defaultHeaders: {
                "X-Langtail-Metadata-key": "value", // optional; 'key' can be any string
              },
            });

            // Then submit a request as usual and it will be proxied through Langtail.
            // Optionally, add headers for easier trace filtering.
            const chatCompletion = await openai.chat.completions.create(
              {
                messages: [{ role: "user", content: "Hello world" }],
                model: "gpt-3.5-turbo",
              },
              {
                headers: {
                  "X-Langtail-Prompt": "prompt-slug", // optional
                  "X-Langtail-Metadata-key": "value", // optional; 'key' can be any string
                },
              }
            );
            console.log(chatCompletion.choices[0].message)
            ```
          </Accordion>

          <Accordion title="OpenAI SDK v3 or lower">
            ```javascript theme={null}
            import { Configuration, OpenAIApi } from "openai";

            // Add basePath to send requests to Langtail instead of directly to OpenAI
            const configuration = new Configuration({
              apiKey: process.env.LANGTAIL_API_KEY,
              basePath: "https://proxy.langtail.com/v1",
              baseOptions: {
                headers: {
                  "X-Langtail-Metadata-key": "value", // optional; 'key' can be any string
                },
              },
            });
            const openai = new OpenAIApi(configuration);

            // Then submit a request as usual and it will be proxied through Langtail.
            // Optionally, add headers for easier trace filtering.
            const chatCompletion = await openai.createChatCompletion(
              {
                model: "gpt-3.5-turbo",
                messages: [{ role: "user", content: "Hello world" }],
              },
              {
                headers: {
                  "X-Langtail-Prompt": "prompt-slug", // optional
                  "X-Langtail-Metadata-key": "value", // optional; 'key' can be any string
                },
              }
            );
            console.log(chatCompletion.data.choices[0].message);
            ```
          </Accordion>
        </AccordionGroup>
      </Tab>

      <Tab title="Python">
        <AccordionGroup>
          <Accordion title="OpenAI SDK v1" defaultOpen>
            ```python theme={null}
            import os

            from openai import OpenAI


            # Add base_url to send requests to Langtail instead of directly to OpenAI
            client = OpenAI(
                api_key=os.environ["LANGTAIL_API_KEY"],
                base_url="https://proxy.langtail.com/v1",
                default_headers={
                    "X-Langtail-Metadata-key": "value",  # optional; 'key' can be any string
                },
            )

            # Then submit a request as usual and it will be proxied through Langtail.
            # Optionally, add headers for easier trace filtering.
            chat_completion = client.chat.completions.create(
                model="gpt-4",
                messages=[{"role": "user", "content": "Hello world!"}],
                extra_headers={
                    "X-Langtail-Prompt": "prompt-slug",  # optional
                    "X-Langtail-Metadata-key": "value",  # optional; 'key' can be any string
                },
            )
            print(chat_completion)
            ```
          </Accordion>

          <Accordion title="OpenAI SDK v0.x">
            ```python theme={null}
            import os

            import openai

            # Add api_base to send requests to Langtail instead of directly to OpenAI
            openai.api_key = os.environ["LANGTAIL_API_KEY"]
            openai.api_base = "https://proxy.langtail.com/v1"

            # Then submit a request as usual and it will be proxied through Langtail.
            # Optionally, add headers for easier trace filtering.
            completion = openai.ChatCompletion.create(
                model="gpt-4",
                messages=[{"role": "user", "content": "Hello world!"}],
                headers={
                    "X-Langtail-Prompt": "prompt-slug",  # optional
                    "X-Langtail-Metadata-key": "value",  # optional; 'key' can be any string
                },
            )
            print(completion)
            ```
          </Accordion>
        </AccordionGroup>
      </Tab>
    </Tabs>
  </Step>

  <Step title="Test it out">
    Run your app and make a request to verify that everything works properly.
  </Step>

  <Step title="Observe metrics and logs">
    <video controls className="w-full aspect-video" src="https://mintcdn.com/langtail-64/ca3hBu6aHdxqHnlL/images/proxy/view-logs.mp4?fit=max&auto=format&n=ca3hBu6aHdxqHnlL&q=85&s=a6488c1520adfb0943e04094d340623d" data-path="images/proxy/view-logs.mp4" />

    1. Back in Langtail, navigate to the project and then click *Logs* in the left sidebar.
    2. You should see log entries coming from your app (they have an environment value of "proxy").
    3. Click on a log to see detailed information about the request and response from OpenAI.
    4. If you want to experiment with this prompt, click *Open in Playground*. Here you can change parameters and modify different parts of the prompt and then see the result.
  </Step>
</Steps>