# Use providers with SDKs
URL: https://metorial.com/docs/build/providers/with-sdks

Connect Metorial provider tools to an LLM and build a chat-enabled app.

---

After you configure provider access in Metorial, you can connect those tools to an LLM like ChatGPT.

In this guide, you'll learn how to build a chat-enabled app that automatically handles tool calls from your Metorial providers.

<PageIntro>
  <Learn>
    * How to use a Metorial provider
    * How to use the Metorial SDKs
  </Learn>

  <Reading title="Before you start">
    * Create a Metorial project
    * Configure at least one provider or integration
    * Create an API key
  </Reading>
</PageIntro>

<Steps>
  <Step title="1. Install the SDKs">
    Run the installer for your language of choice:

    <CodeBlockTabs defaultValue="TypeScript" groupId="language" mode="shell">
      <CodeBlockTabsList>
        <CodeBlockTabsTrigger value="TypeScript">
          TypeScript
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="Python">
          Python
        </CodeBlockTabsTrigger>
      </CodeBlockTabsList>

      <CodeBlockTab value="TypeScript">
        <Shell>
          <Command>
            npm install metorial @metorial/openai openai
          </Command>
        </Shell>
      </CodeBlockTab>

      <CodeBlockTab value="Python">
        <Shell>
          <Command>
            pip install metorial openai
          </Command>
        </Shell>
      </CodeBlockTab>
    </CodeBlockTabs>
  </Step>

  <Step title="2. Configure clients">
    Instantiate both clients with your API keys and your provider deployment ID.

    ```typescript TypeScript
    import { Metorial } from 'metorial';
    import { metorialOpenAI } from '@metorial/openai';
    import OpenAI from 'openai';

    let metorial = new Metorial({
      apiKey: 'metorial_sk_io2h4...'
    });

    let openai = new OpenAI({
      apiKey: '...your-openai-api-key...'
    });
    ```

    ```python Python
    from metorial import Metorial, metorial_openai
    from openai import AsyncOpenAI

    metorial = Metorial(api_key="metorial_sk_io2h4...")
    openai = AsyncOpenAI(api_key="...your-openai-api-key...")
    ```
  </Step>

  <Step title="3. Fetch your provider tools">
    Create a session that exposes your deployed provider tools.

    ```typescript TypeScript
    let session = await metorial.connect({
    	adapter: metorialOpenAI.chatCompletions(),
    	providers: [
    		{ providerDeploymentId: '...your-provider-deployment-id...' }
    	]
    });

    let tools = session.tools();
    ```

    ```python Python
    session = await metorial.connect(
        adapter=metorial_openai(),
        providers=[{"provider_deployment_id": "...your-provider-deployment-id..."}],
    )
    tools = session.tools()
    ```
  </Step>

  <Step title="4. Send your first prompt">
    Kick off the loop by sending an initial message.

    ```typescript TypeScript
    let messages = [
      { role: "user", content: "Summarize the README.md file of the metorial/websocket-explorer repository on GitHub." }
    ];
    ```

    ```python Python
    messages = [
      {"role": "user", "content": "Summarize the README.md file of the metorial/websocket-explorer repository on GitHub."}
    ]
    ```
  </Step>

  <Step title="5. Loop & handle tool calls">
    1. Send `messages` to OpenAI, passing the tools.
    2. If the assistant response contains `tool_calls`, invoke it:

    ```typescript TypeScript
    let response = await openai.chat.completions.create({
      model: 'gpt-4o',
      messages,
      tools
    });
    let choice = response.choices[0]!;
    let toolCalls = choice.message.tool_calls;
    let toolResults = await session.callTools(toolCalls);
    ```

    ```python Python
    response = await openai.chat.completions.create(
      model="gpt-4o",
      messages=messages,
      tools=session.tools(),
    )
    choice = response.choices[0]
    tool_calls = choice.message.tool_calls
    tool_results = await session.call_tools(tool_calls)
    ```

    3. Append both the tool call requests and their results to `messages`.
    4. Repeat until the assistant's response has no more `tool_calls`.
  </Step>

  <Step title="6. Display the final output">
    Once there are no more tool calls, your assistant's final reply is in:

    ```typescript TypeScript
    console.log(choice.message.content);
    ```

    ```python Python
    print(choice.message.content)
    ```
  </Step>
</Steps>