pip install netra-sdk aleph-alpha-client

npm install netra-sdk aleph-alpha-client

from netra import Netra

# Initialize Netra with your API key
Netra.init(
    app_name="my-aleph-alpha-app",
    headers=f"x-api-key={os.environ['NETRA_API_KEY']}",
    trace_content=True
)

# Your Aleph Alpha code will be automatically traced

import { Netra } from "netra-sdk";

// Initialize Netra with your API key (must await)
await Netra.init({
  appName: "my-aleph-alpha-app",
  headers: `x-api-key=${process.env.NETRA_API_KEY}`,
  traceContent: true
});

// Your Aleph Alpha code will be automatically traced

from netra import Netra
from aleph_alpha_client import Client, CompletionRequest, Prompt
import os

# Initialize Netra
Netra.init(
    app_name="my-aleph-alpha-app",
    headers=f"x-api-key={os.environ['NETRA_API_KEY']}",
    trace_content=True
)

# Use Aleph Alpha normally - automatically traced
client = Client(token=os.environ["ALEPH_ALPHA_API_KEY"])

request = CompletionRequest(
    prompt=Prompt.from_text("What is AI?"),
    maximum_tokens=100
)

response = client.complete(request, model="luminous-base")
print(response.completions[0].completion)

import { Netra } from "netra-sdk";
import { AlephAlphaClient } from "aleph-alpha-client";

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

// Use Aleph Alpha normally - automatically traced
const client = new AlephAlphaClient({
  apiKey: process.env.ALEPH_ALPHA_API_KEY
});

const response = await client.complete({
  model: "luminous-base",
  prompt: "Explain quantum computing in simple terms.",
  maximum_tokens: 100
});

console.log(response.completions[0].completion);

from netra.decorators import workflow, task
from netra import Netra
from aleph_alpha_client import Client, CompletionRequest, Prompt

Netra.init(
    headers=f"x-api-key={os.environ['NETRA_API_KEY']}"
)

client = Client(token=os.environ["ALEPH_ALPHA_API_KEY"])

@workflow()
def process_document(text: str):
    summary = summarize_text(text)
    keywords = extract_keywords(summary)
    return {"summary": summary, "keywords": keywords}

@task()
def summarize_text(text: str):
    request = CompletionRequest(
        prompt=Prompt.from_text(f"Summarize: {text}"),
        maximum_tokens=150
    )
    response = client.complete(request, model="luminous-extended")
    return response.completions[0].completion

@task()
def extract_keywords(text: str):
    request = CompletionRequest(
        prompt=Prompt.from_text(f"Extract keywords: {text}"),
        maximum_tokens=50
    )
    response = client.complete(request, model="luminous-base")
    return response.completions[0].completion

import { Netra, workflow, task } from "netra-sdk";
import { AlephAlphaClient } from "aleph-alpha-client";

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

const client = new AlephAlphaClient({
  apiKey: process.env.ALEPH_ALPHA_API_KEY
});

@workflow()
async function processDocument(text: string) {
  const summary = await summarizeText(text);
  const keywords = await extractKeywords(summary);
  return { summary, keywords };
}

@task()
async function summarizeText(text: string) {
  const response = await client.complete({
    model: "luminous-extended",
    prompt: `Summarize the following text:\n\n${text}`,
    maximum_tokens: 150
  });
  return response.completions[0].completion;
}

@task()
async function extractKeywords(text: string) {
  const response = await client.complete({
    model: "luminous-base",
    prompt: `Extract key topics from:\n\n${text}`,
    maximum_tokens: 50
  });
  return response.completions[0].completion;
}

from netra import Netra, ConversationType

# Start a user session
Netra.start_session(
    session_id="user-session-123",
    user_id="user-456",
    metadata={"app": "chatbot"}
)

# Start a conversation
Netra.start_conversation(
    conversation_type=ConversationType.CHAT,
    metadata={"topic": "AI"}
)

# Add messages to the conversation
Netra.add_message(role="user", content="Tell me about Aleph Alpha")

# Your Aleph Alpha call here...

# End conversation when done
Netra.end_conversation()

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

// Start a user session
Netra.startSession({
  sessionId: "user-session-123",
  userId: "user-456",
  metadata: { channel: "web" }
});

// Start a conversation
Netra.startConversation({
  conversationId: "conv-789",
  sessionId: "user-session-123",
  conversationType: ConversationType.CHAT
});

// Add messages to the conversation
Netra.addMessageToConversation({
  conversationId: "conv-789",
  role: "user",
  content: "What is Aleph Alpha?"
});

// Your Aleph Alpha call here...

Netra.addMessageToConversation({
  conversationId: "conv-789",
  role: "assistant",
  content: "Aleph Alpha is a European AI company..."
});

// End conversation when done
Netra.endConversation("conv-789");
Netra.endSession("user-session-123");