Python SDK

pip install tensoras

from tensoras import Tensoras
 
client = Tensoras(api_key="tns_your_key_here")
 
response = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[
        {"role": "user", "content": "Explain RAG in one sentence."},
    ],
)
 
print(response.choices[0].message.content)

export TENSORAS_API_KEY="tns_your_key_here"

from tensoras import Tensoras
 
client = Tensoras()  # reads TENSORAS_API_KEY from env

client = Tensoras(
    api_key="tns_...",
    base_url="http://localhost:8000/v1",
)

from tensoras import AsyncTensoras
 
client = AsyncTensoras()  # reads TENSORAS_API_KEY from env
 
async def main():
    response = await client.chat.completions.create(
        model="llama-3.3-70b",
        messages=[
            {"role": "user", "content": "What is hybrid search?"},
        ],
    )
    print(response.choices[0].message.content)

response = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the capital of France?"},
    ],
    temperature=0.7,
    max_tokens=256,
)
 
print(response.choices[0].message.content)

stream = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[
        {"role": "user", "content": "Write a short poem about APIs."},
    ],
    stream=True,
)
 
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)
 
print()

from tensoras import AsyncTensoras
 
client = AsyncTensoras()
 
stream = await client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[
        {"role": "user", "content": "Write a short poem about APIs."},
    ],
    stream=True,
)
 
async for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)
 
print()

response = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[
        {"role": "system", "content": "Return JSON with keys: name, genre, year."},
        {"role": "user", "content": "Tell me about Inception."},
    ],
    response_format={"type": "json_object"},
)
 
import json
data = json.loads(response.choices[0].message.content)

response = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[
        {"role": "system", "content": "Extract movie data."},
        {"role": "user", "content": "Tell me about Inception."},
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "movie",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "year": {"type": "integer"},
                    "genre": {"type": "string"},
                },
                "required": ["name", "year", "genre"],
                "additionalProperties": False,
            },
        },
    },
)

from tensoras.types import ResponseFormatJsonSchema, JsonSchemaConfig
 
response = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[
        {"role": "user", "content": "Tell me about Inception."},
    ],
    response_format=ResponseFormatJsonSchema(
        json_schema=JsonSchemaConfig(
            name="movie",
            strict=True,
            schema={
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "year": {"type": "integer"},
                },
                "required": ["name", "year"],
                "additionalProperties": False,
            },
        ),
    ),
)

response = client.embeddings.create(
    model="gte-large-en-v1.5",
    input="The quick brown fox jumps over the lazy dog.",
)
 
embedding = response.data[0].embedding
print(f"Dimensions: {len(embedding)}")

response = client.rerank.create(
    model="bge-reranker-v2-m3",
    query="What is deep learning?",
    documents=[
        "Deep learning is a subset of machine learning.",
        "The weather today is sunny.",
        "Neural networks are the foundation of deep learning.",
    ],
)
 
for result in response.results:
    print(f"Index: {result.index}, Score: {result.relevance_score:.4f}")

kb = client.knowledge_bases.create(
    name="support-docs",
    description="Customer support documentation",
)
 
print(kb.id)  # e.g. "kb_a1b2c3d4"

knowledge_bases = client.knowledge_bases.list()
 
for kb in knowledge_bases.data:
    print(f"{kb.id}: {kb.name}")

kb = client.knowledge_bases.retrieve("kb_a1b2c3d4")
print(kb.name, kb.status)

data_source = client.knowledge_bases.data_sources.create(
    knowledge_base_id="kb_a1b2c3d4",
    type="file_upload",
    file=open("handbook.pdf", "rb"),
)
 
print(data_source.status)  # "processing" -> "completed"

documents = client.knowledge_bases.documents.list(
    knowledge_base_id="kb_a1b2c3d4",
)
 
for doc in documents.data:
    print(f"{doc.id}: {doc.filename} ({doc.status})")

response = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[
        {"role": "user", "content": "How do I reset my password?"},
    ],
    knowledge_bases=["kb_a1b2c3d4"],
)
 
print(response.choices[0].message.content)
 
for citation in response.citations:
    print(f"  Source: {citation.source}, Score: {citation.score:.3f}")

from tensoras import Tensoras, TensorasAPIError, AuthenticationError, RateLimitError
 
client = Tensoras()
 
try:
    response = client.chat.completions.create(
        model="llama-3.3-70b",
        messages=[{"role": "user", "content": "Hello"}],
    )
except AuthenticationError:
    print("Invalid or missing API key.")
except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after}s.")
except TensorasAPIError as e:
    print(f"API error {e.status_code}: {e.message}")

client = Tensoras(
    max_retries=5,        # default: 3
    timeout=60.0,         # request timeout in seconds, default: 120
)

client = Tensoras(max_retries=0)

models = client.models.list()
 
for model in models.data:
    print(f"{model.id}: {model.owned_by}")