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

# Novita AI

> Trace Novita AI OpenAI-compatible API calls with OpenInference and send spans to Arize AX for LLM observability.

[Novita AI](https://novita.ai/) provides model APIs with OpenAI-compatible chat completions support. Point the OpenAI client at Novita's OpenAI-compatible endpoint and use [`openinference-instrumentation-openai`](https://github.com/Arize-ai/openinference/tree/main/python/instrumentation/openinference-instrumentation-openai) to send traces to Arize AX.

> [!NOTE]
>
> This page uses Novita AI's OpenAI-compatible API. There is no separate Novita-specific OpenInference instrumentor required.

## Prerequisites

* Python 3.9+
* An Arize AX account ([sign up](https://arize.com/sign-up/))
* A `NOVITA_API_KEY` from Novita AI

## Launch Arize

1. Sign in to your [Arize AX account](https://app.arize.com/).
2. From **Space Settings**, copy your **Space ID** and **API Key**. You will set them as `ARIZE_SPACE_ID` and `ARIZE_API_KEY` below.

## Install

```bash theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
pip install arize-otel openinference-instrumentation-openai openai
```

## Configure credentials

```bash theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
export ARIZE_SPACE_ID="<your-space-id>"
export ARIZE_API_KEY="<your-api-key>"
export ARIZE_PROJECT_NAME="novita-ai-tracing-example"
export NOVITA_API_KEY="<your-novita-api-key>"
export NOVITA_MODEL="<your-novita-model-id>"
```

## Setup tracing

```python theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
# instrumentation.py
import os

from arize.otel import register
from openinference.instrumentation.openai import OpenAIInstrumentor

tracer_provider = register(
    space_id=os.environ["ARIZE_SPACE_ID"],
    api_key=os.environ["ARIZE_API_KEY"],
    project_name=os.environ["ARIZE_PROJECT_NAME"],
)

OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)
print("Arize AX tracing initialized for Novita AI.")
```

## Run Novita AI

```python theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
# example.py

# Importing instrumentation first ensures tracing is set up
# before `openai` is imported.
from instrumentation import tracer_provider

import os

from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/openai",
    api_key=os.environ["NOVITA_API_KEY"],
)

response = client.chat.completions.create(
    model=os.environ["NOVITA_MODEL"],
    messages=[
        {
            "role": "user",
            "content": "What should teams inspect when an LLM answer is wrong?",
        },
    ],
)

print(response.choices[0].message.content)
```

### Expected output

```text wrap theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
Arize AX tracing initialized for Novita AI.
Teams should inspect the prompt, retrieved context, tool calls, model response, latency, token usage, and any errors or retries in the trace.
```

## Verify in Arize

1. Open your Arize AX space and select project **`novita-ai-tracing-example`**.
2. You should see a new trace within \~30 seconds containing a `ChatCompletion` LLM span with prompt, response, model, token, and latency metadata.
3. If no traces appear, see [Troubleshooting](#troubleshooting).

### Check from the skill, CLI, or SDK

Confirm spans are actually reaching your Arize AX project. Use whichever fits your workflow — the skill and CLI work for any framework; the SDK check is shown for each language.

**Arize skill (agent)**

Install the [Arize Skills](https://github.com/Arize-ai/arize-skills) plugin and let your coding agent check for you:

```bash theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
npx skills add Arize-ai/arize-skills
```

Then prompt your agent:

> Use the `arize-trace` skill to export and analyze recent traces from my project. Confirm spans are arriving, and summarize any errors or latency issues.

**AX CLI**

Export recent spans for your project — any rows mean traces are landing:

```bash theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
ax spans export "$ARIZE_PROJECT_NAME" --space "$ARIZE_SPACE_ID" \
  --limit 5 --stdout | jq 'length'
```

A non-zero count confirms spans reached Arize AX. Run `ax auth login` first if you have not authenticated. See the [`ax spans` reference](/docs/api-clients/cli/spans).

**SDK**

Query the project's spans and check that at least one came back.

```python Python theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
import os
from arize import ArizeClient

client = ArizeClient(api_key=os.environ["ARIZE_API_KEY"])
resp = client.spans.list(
    project=os.environ["ARIZE_PROJECT_NAME"],
    space=os.environ["ARIZE_SPACE_ID"],
    limit=5,
)
count = len(resp.spans)
print(
    f"{count} span(s) found" if count else "No spans yet — recheck setup"
)
```

```typescript TypeScript theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
// Reads ARIZE_API_KEY from the environment.
import { listSpans } from "@arizeai/ax-client";

const { data: spans } = await listSpans({
  project: process.env.ARIZE_PROJECT_NAME!,
  space: process.env.ARIZE_SPACE_ID!,
  limit: 5,
});
const count = spans.length;
console.log(
  count ? `${count} span(s) found` : "No spans yet — recheck setup",
);
```

```go Go theme={"theme":{"light":"github-light-default","dark":"github-dark-default"}}
client, err := arize.NewClient(
    arize.Config{APIKey: os.Getenv("ARIZE_API_KEY")},
)
if err != nil {
    log.Fatal(err)
}
resp, err := client.Spans.List(ctx, spans.ListRequest{
    Project: os.Getenv("ARIZE_PROJECT_NAME"),
    Space:   os.Getenv("ARIZE_SPACE_ID"),
    Limit:   5,
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("%d span(s) found\n", len(resp.Spans))
```

SDK span references: [Python](/docs/api-clients/python/version-8/client-resources/spans) · [TypeScript](/docs/api-clients/typescript/version-1/client-resources/spans) · [Go](/docs/api-clients/go/version-2/client-resources/spans).

## Troubleshooting

* **No traces in Arize.** Confirm `ARIZE_SPACE_ID` and `ARIZE_API_KEY` are set in the same shell that runs `example.py`.
* **Novita spans missing but other spans present.** `OpenAIInstrumentor().instrument(...)` must run before any `import openai`.
* **`401` from Novita.** Use your Novita API key, not your OpenAI or Arize API key.
* **Model not found.** Confirm `NOVITA_MODEL` matches a model identifier available in your Novita account.

## Resources

> **[Novita AI LLM API](https://novita.ai/docs/guides/llm-api)**

> **[OpenInference OpenAI Instrumentor](https://github.com/Arize-ai/openinference/tree/main/python/instrumentation/openinference-instrumentation-openai)**

> **[LLM Evaluation Guide](https://arize.com/resources/llm-evaluation/)**

> **[Agent Evaluation Guide](https://arize.com/guides/ai-agent-handbook/agent-evaluation/)**