Trace your code ↗

    import weave

    from openai import OpenAI
    client = OpenAI()

    # Initialize Weave Tracing
    weave.init('intro-example')

    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {
                "role": "user",
                "content": "How are you?"
            }
        ],
        temperature=0.8,
        max_tokens=64,
        top_p=1,
    )
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="TypeScript"></span>
```typescript
    import OpenAI from 'openai'
    import * as weave from 'weave'

    const client = new OpenAI()

    // Initialize Weave Tracing
    await weave.init('intro-example')

    const response = await client.chat.completions.create({
      model: 'gpt-4',
      messages: [
        {
          role: 'user',
          content: 'How are you?',
        },
      ],
      temperature: 0.8,
      max_tokens: 64,
      top_p: 1,
    });
    ```

For a complete setup guide for JS / TS projects, see the [TypeScript SDK: Third-Party Integration Guide](/weave/guides/integrations/js).
  <span class="tab-end"></span>
<span class="tab-group-end"></span>

If you want more control over automatic behavior, see [Configure automatic LLM call tracking](/weave/guides/integrations/autopatching).

## 2. Tracking of custom functions

Often LLM applications have additional logic (such as pre/post processing, prompts, and more) that you want to track.

<span class="tab-group-start"></span>
  <span class="tab-start" data-tab-title="Python"></span>
Weave allows you to manually track these Calls using the [`@weave.op`](/weave/reference/python-sdk/#function-op) decorator. For example:

```python
    import weave

    # Initialize Weave Tracing
    weave.init('intro-example')

    # Decorate your function
    @weave.op
    def my_function(name: str):
        return f"Hello, {name}!"

    # Call your function -- Weave will automatically track inputs and outputs
    print(my_function("World"))
    ```

You can also track [methods on classes](#track-class-and-object-methods).
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="TypeScript"></span>
Weave allows you to manually track these Calls by wrapping your function with [`weave.op`](/weave/reference/typescript-sdk/functions/op). For example:

```typescript
    import * as weave from 'weave'

    await weave.init('intro-example')

    function myFunction(name: string) {
        return `Hello, ${name}!`
    }

    const myFunctionOp = weave.op(myFunction)
    ```

You can also define the wrapping inline:

```typescript
    const myFunctionOp = weave.op((name: string) => `Hello, ${name}!`)
    ```

This works for both functions as well as methods on classes:

```typescript
    class MyClass {
        constructor() {
            this.myMethod = weave.op(this.myMethod)
        }

        myMethod(name: string) {
            return `Hello, ${name}!`
        }
    }
    ```
  <span class="tab-end"></span>
<span class="tab-group-end"></span>

### Track class and object methods

You can also track class and object methods. You can track any method in a class by decorating the method with `weave.op`.

<span class="tab-group-start"></span>
  <span class="tab-start" data-tab-title="Python"></span>
```python
    import weave

    # Initialize Weave Tracing
    weave.init("intro-example")

    class MyClass:
        # Decorate your method
        @weave.op
        def my_method(self, name: str):
            return f"Hello, {name}!"

    instance = MyClass()

    # Call your method -- Weave will automatically track inputs and outputs
    print(instance.my_method("World"))
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="TypeScript"></span>
<span class="callout-start" data-callout-type="important"></span>
  **Using decorators in TypeScript**

  To use the `@weave.op` decorator with your TypeScript code, make sure your environment is properly configured:

  * **TypeScript v5.0 or newer**: Decorators are supported out of the box and no additional configuration is required.
  * **TypeScript older than v5.0**: Enable experimental support for decorators. For more details, see the [official TypeScript documentation on decorators](https://www.typescriptlang.org/docs/handbook/decorators.html).
<span class="callout-end"></span>

You can apply `@weave.op` to instance methods for tracing.

```typescript
    class Foo {
        @weave.op
        async predict(prompt: string) {
            return "bar"
        }
    }
    ```

You can also apply `@weave.op` to static methods to monitor utility functions within a class.

```typescript
    class MathOps {
        @weave.op
        static square(n: number): number {
            return n * n;
        }
    }
    ```
  <span class="tab-end"></span>
<span class="tab-group-end"></span>

### Trace parallel (multi-threaded) function calls

By default, parallel Calls all show up in Weave as separate root Calls. To get correct nesting under the same parent Op, use a `ThreadPoolExecutor`.

<span class="tab-group-start"></span>
  <span class="tab-start" data-tab-title="Python"></span>
The following code sample demonstrates the use of [`ThreadPoolExecutor`](/weave/reference/python-sdk/trace/util#class-contextawarethreadpoolexecutor).
The first function, `func`, is a simple Op that takes `x` and returns `x+1`. The second function, `outer`, is another Op that accepts a list of inputs.
Inside `outer`, the use of `ThreadPoolExecutor` and `exc.map(func, inputs)` means that each call to `func` still carries the same parent trace context.

```python
    import weave

    @weave.op
    def func(x):
        return x+1

    @weave.op
    def outer(inputs):
        with weave.ThreadPoolExecutor() as exc:
            exc.map(func, inputs)

    # Update your Weave project name
    client = weave.init('my-weave-project')
    outer([1,2,3,4,5])
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="TypeScript"></span>
```plaintext
    This feature is not available in the TypeScript SDK yet.
    ```
  <span class="tab-end"></span>
<span class="tab-group-end"></span>

In the Weave UI, this produces a single parent Call with five nested child Calls, so that you get a fully hierarchical trace even though the increments run in parallel.

<img src="https://mintcdn.com/wb-21fd5541/4ANo4MV8FzCjYewG/weave/guides/tracking/imgs/threadpoolexecutor.png?fit=max&auto=format&n=4ANo4MV8FzCjYewG&q=85&s=ec1fa79cd0f5817a7b5de1aed5aca11c" alt="The Trace UI, showing a single parent Call for outer, with five nested child Calls." width="720" height="418" data-path="weave/guides/tracking/imgs/threadpoolexecutor.png" />

## 3. Manual Call tracking

You can also manually create Calls using the API directly.

<span class="tab-group-start"></span>
  <span class="tab-start" data-tab-title="Python"></span>
```python
    import weave

    # Initialize Weave Tracing
    client = weave.init('intro-example')

    def my_function(name: str):
        # Start a Call
        call = client.create_call(op="my_function", inputs={"name": name})

        # ... your function code ...

        # End a Call
        client.finish_call(call, output="Hello, World!")

        # Call your function
        print(my_function("World"))
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="TypeScript"></span>
```plaintext
    This feature is not available in the TypeScript SDK yet.
    ```
  <span class="tab-end"></span>

  <span class="tab-start" data-tab-title="HTTP API"></span>
* Start a Call: [POST `/call/start`](https://docs.wandb.ai/weave/reference/service-api/calls/call-start).
* End a Call: [POST `/call/end`](https://docs.wandb.ai/weave/reference/service-api/calls/call-end).

```bash
    curl -L 'https://trace.wandb.ai/call/start' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -d '{
        "start": {
            "project_id": "string",
            "id": "string",
            "op_name": "string",
            "display_name": "string",
            "trace_id": "string",
            "parent_id": "string",
            "started_at": "2024-09-08T20:07:34.849Z",
            "attributes": {},
            "inputs": {},
            "wb_run_id": "string"
        }
    }
    ```
  <span class="tab-end"></span>
<span class="tab-group-end"></span>