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

# Cerebras

> Trace Cerebras ultra-fast AI inference with Netra auto-instrumentation. Monitor model calls, token throughput, and latency across all inference runs.

<img src="https://mintcdn.com/netra/u6ajHWd7ki_9CRWQ/images/integration-logos/ai-frameworks/cerebras.png?fit=max&auto=format&n=u6ajHWd7ki_9CRWQ&q=85&s=812bbc5f8f7f97cdbab322008803794a" alt="Cerebras" width="182" height="80" data-path="images/integration-logos/ai-frameworks/cerebras.png" />

## Installation

Install both the Netra SDK and Cerebras:

<CodeGroup>
  ```bash Python theme={null}
  pip install netra-sdk cerebras-cloud-sdk
  ```

  ```bash Typescript theme={null}
  npm install netra-sdk @cerebras/cerebras_cloud_sdk
  ```
</CodeGroup>

## Usage

Initialize the Netra SDK to automatically trace all Cerebras operations:

<CodeGroup>
  ```python Python theme={null}
  from netra import Netra
  from cerebras.cloud.sdk import Cerebras
  import os

  # Initialize Netra
  Netra.init(
      headers=f"x-api-key={os.environ.get('NETRA_API_KEY')}",
      trace_content=True
  )

  # Create Cerebras client - automatically traced
  client = Cerebras(api_key=os.environ.get('CEREBRAS_API_KEY'))

  # Use Cerebras as normal
  response = client.chat.completions.create(
      model="llama3.1-8b",
      messages=[{"role": "user", "content": "What is Cerebras?"}]
  )
  print(response.choices[0].message.content)
  ```

  ```typescript Typescript theme={null}
  import { Netra } from "netra-sdk";
  import Cerebras from "@cerebras/cerebras_cloud_sdk";

  // Initialize Netra
  await Netra.init({
    headers: `x-api-key=${process.env.NETRA_API_KEY}`,
    traceContent: true
  });

  // Create Cerebras client - automatically traced
  const client = new Cerebras({
    apiKey: process.env.CEREBRAS_API_KEY
  });

  // Use Cerebras as normal
  const response = await client.chat.completions.create({
    model: "llama3.1-8b",
    messages: [{ role: "user", content: "What is Cerebras?" }]
  });
  console.log(response.choices[0].message.content);
  ```
</CodeGroup>

### Chat Completions

Trace chat completions with decorators:

<CodeGroup>
  ```python Python theme={null}
  from netra.decorators import task
  from netra import SpanWrapper
  from cerebras.cloud.sdk import Cerebras

  @task()
  def chat_completion(client: Cerebras, prompt: str) -> str:
      span = SpanWrapper("cerebras-chat", {
          "prompt": prompt,
          "model": "llama3.1-8b"
      }).start()
      
      response = client.chat.completions.create(
          model="llama3.1-8b",
          messages=[{"role": "user", "content": prompt}]
      )
      
      answer = response.choices[0].message.content
      span.set_attribute("response", answer)
      span.set_attribute("tokens.completion", response.usage.completion_tokens)
      span.end()
      
      return answer
  ```

  ```typescript Typescript theme={null}
  import { task, SpanWrapper } from "netra-sdk";
  import Cerebras from "@cerebras/cerebras_cloud_sdk";

  @task()
  async function chatCompletion(client: Cerebras, prompt: string): Promise<string> {
    const span = new SpanWrapper("cerebras-chat", {
      "prompt": prompt,
      "model": "llama3.1-8b"
    }).start();
    
    const response = await client.chat.completions.create({
      model: "llama3.1-8b",
      messages: [{ role: "user", content: prompt }]
    });
    
    const answer = response.choices[0].message.content;
    span.setAttribute("response", answer);
    span.setAttribute("tokens.completion", response.usage?.completion_tokens || 0);
    span.end();
    
    return answer;
  }
  ```
</CodeGroup>

### Streaming Responses

Trace streaming completions:

<CodeGroup>
  ```python Python theme={null}
  from netra.decorators import task
  from netra import SpanWrapper

  @task()
  def stream_completion(client: Cerebras, prompt: str):
      stream_span = SpanWrapper("cerebras-stream").start()
      
      response = client.chat.completions.create(
          model="llama3.1-8b",
          messages=[{"role": "user", "content": prompt}],
          stream=True
      )
      
      full_response = ""
      for chunk in response:
          if chunk.choices[0].delta.content:
              content = chunk.choices[0].delta.content
              print(content, end='', flush=True)
              full_response += content
      
      stream_span.set_attribute("response", full_response)
      stream_span.end()
      
      return full_response
  ```

  ```typescript Typescript theme={null}
  import { task, SpanWrapper } from "netra-sdk";

  @task()
  async function streamCompletion(client: Cerebras, prompt: string) {
    const streamSpan = new SpanWrapper("cerebras-stream").start();
    
    const response = await client.chat.completions.create({
      model: "llama3.1-8b",
      messages: [{ role: "user", content: prompt }],
      stream: true
    });
    
    let fullResponse = "";
    for await (const chunk of response) {
      if (chunk.choices[0]?.delta?.content) {
        const content = chunk.choices[0].delta.content;
        process.stdout.write(content);
        fullResponse += content;
      }
    }
    
    streamSpan.setAttribute("response", fullResponse);
    streamSpan.end();
    
    return fullResponse;
  }
  ```
</CodeGroup>

### Multi-turn Conversations

Trace conversation history:

<CodeGroup>
  ```python Python theme={null}
  from netra.decorators import agent
  from netra import SpanWrapper

  @agent()
  def conversation(client: Cerebras, messages: list[dict]):
      conv_span = SpanWrapper("cerebras-conversation", {
          "messages.count": len(messages)
      }).start()
      
      response = client.chat.completions.create(
          model="llama3.1-8b",
          messages=messages
      )
      
      answer = response.choices[0].message.content
      conv_span.set_attribute("response", answer)
      conv_span.end()
      
      return answer
  ```

  ```typescript Typescript theme={null}
  import { agent, SpanWrapper } from "netra-sdk";

  @agent()
  async function conversation(client: Cerebras, messages: Array<any>) {
    const convSpan = new SpanWrapper("cerebras-conversation", {
      "messages.count": messages.length
    }).start();
    
    const response = await client.chat.completions.create({
      model: "llama3.1-8b",
      messages: messages
    });
    
    const answer = response.choices[0].message.content;
    convSpan.setAttribute("response", answer);
    convSpan.end();
    
    return answer;
  }
  ```
</CodeGroup>

### Model Configuration

Trace with different models and settings:

<CodeGroup>
  ```python Python theme={null}
  from netra.decorators import workflow
  from netra import SpanWrapper

  @workflow()
  def generate_with_config(client: Cerebras, prompt: str, temperature: float = 0.7):
      config_span = SpanWrapper("cerebras-configured", {
          "prompt": prompt,
          "temperature": temperature
      }).start()
      
      response = client.chat.completions.create(
          model="llama3.1-70b",
          messages=[{"role": "user", "content": prompt}],
          temperature=temperature,
          max_tokens=1000
      )
      
      result = response.choices[0].message.content
      config_span.set_attribute("response", result)
      config_span.end()
      
      return result
  ```

  ```typescript Typescript theme={null}
  import { workflow, SpanWrapper } from "netra-sdk";

  @workflow()
  async function generateWithConfig(client: Cerebras, prompt: string, temperature: number = 0.7) {
    const configSpan = new SpanWrapper("cerebras-configured", {
      "prompt": prompt,
      "temperature": temperature
    }).start();
    
    const response = await client.chat.completions.create({
      model: "llama3.1-70b",
      messages: [{ role: "user", content: prompt }],
      temperature: temperature,
      max_tokens: 1000
    });
    
    const result = response.choices[0].message.content;
    configSpan.setAttribute("response", result);
    configSpan.end();
    
    return result;
  }
  ```
</CodeGroup>

## Configuration

Configure Cerebras instrumentation:

<CodeGroup>
  ```python Python theme={null}
  from netra import Netra
  from netra.instrumentation.instruments import InstrumentSet

  Netra.init(
      headers=f"x-api-key={os.environ.get('NETRA_API_KEY')}",
      trace_content=True,
      instruments={InstrumentSet.CEREBRAS}
  )
  ```

  ```typescript Typescript theme={null}
  import { Netra, NetraInstruments } from "netra-sdk";

  Netra.init({
    headers: `x-api-key=${process.env.NETRA_API_KEY}`,
    traceContent: true,
    instruments: new Set([NetraInstruments.CEREBRAS])
  });
  ```
</CodeGroup>

## Next Steps

* [Quick Start Guide](https://docs.getnetra.ai/quick-start/python) - Complete setup and configuration
* [Decorators](https://docs.getnetra.ai/tracing/decorators) - Add custom tracing with `@workflow`, `@agent`, and `@task` decorators
* [Cerebras Documentation](https://inference-docs.cerebras.ai/quickstart) - Official Cerebras documentation