Cerebras

pip install netra-sdk cerebras-cloud-sdk

npm install netra-sdk @cerebras/cerebras_cloud_sdk

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)

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);

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

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;
}

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

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;
}

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

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;
}

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

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;
}

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}
)

import { Netra, NetraInstruments } from "netra-sdk";

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