Building a Sentiment Analysis Tool with LLM

#aiinfrastructure #oxlo #ai

Sentiment analysis remains one of the most practical entry points for teams integrating LLMs into production. Unlike traditional classifier pipelines that demand labeled datasets and retraining cycles, a modern LLM can infer polarity, emotion, and intent from raw text with minimal prompt engineering. For developers, the infrastructure question is not whether an LLM can classify sentiment, but which platform delivers consistent latency and predictable costs when processing thousands of variable-length customer feedback entries.

Why Use an LLM for Sentiment Analysis

Classical approaches rely on bag-of-words models or fine-tuned transformers that generalize poorly across domains. An LLM captures context, nuance, and implicit tone without retraining. You can move from a simple positive or negative label to granular outputs such as mixed, sarcastic, or aspect-based sentiment, all within a single API call. This flexibility makes LLMs ideal for support tickets, social media monitoring, and product review aggregation.

Structured Prompts and JSON Mode

To make the output machine readable, constrain the model with a system prompt and request JSON. The following pattern works reliably across instruction-tuned models.

SYSTEM_PROMPT = """You are a sentiment analysis engine.
Read the user text and return a JSON object with exactly two keys:
  - 'sentiment': one of ['positive', 'negative', 'neutral', 'mixed']
  - 'confidence': a float between 0.0 and 1.0.
Do not include markdown formatting or explanation."""

This removes the need for fragile regex parsing and integrates directly with downstream pipelines.

Implementation with the OpenAI SDK on Oxlo.ai

Oxlo.ai exposes a fully OpenAI-compatible API at https://api.oxlo.ai/v1. You can use the official Python SDK without code changes. In this example we use Llama 3.3 70B, a general-purpose flagship model available on Oxlo.ai, but you can substitute Qwen 3 32B or DeepSeek V3.2 depending on your latency and language requirements.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.oxlo.ai/v1",
    api_key=os.environ.get("OXLO_API_KEY")
)

MODEL = "llama-3.3-70b"

def analyze_sentiment(text: str) -> str:
    response = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": text}
        ],
        response_format={"type": "json_object"},
        temperature=0.1,
        max_tokens=256
    )
    return response.choices[0].message.content

# Batch example
reviews = [
    "The battery life on this laptop is incredible, but the fan noise is unbearable.",
    "Shipping was fast. Packaging was fine. No complaints."
]

for review in reviews:
    result = analyze_sentiment(review)
    print(result)

Setting temperature low keeps the output deterministic, while response_format={"type": "json_object"} guarantees valid JSON when supported by the model. Oxlo.ai supports JSON mode and multi-turn conversations across its LLM catalog, so this pattern ports cleanly to reasoning models such as DeepSeek R1 671B MoE if you need chain-of-thought analysis before the final classification.

Cost Predictability for Variable-Length Inputs

Sentiment analysis workloads often involve unpredictable input sizes. A support ticket might be fifty words or five thousand. On token-based providers, a spike in long-form feedback directly inflates your bill. Oxlo.ai uses request-based pricing: one flat cost per API request regardless of prompt length. For batch processing of long customer conversations or document-level sentiment extraction, this can be significantly cheaper than token-based alternatives. See https://oxlo.ai/pricing for current plan details.

Production Considerations

Validation. Always validate JSON with pydantic or jsonschema before persisting results. Even with JSON mode, edge cases occur.
Caching. Hash the input text and cache responses to avoid redundant classification. Oxlo.ai offers no cold starts on popular models, so cache misses still resolve quickly.
Model fallback. If your primary model is rate limited, Oxlo.ai provides 45+ models across seven categories. A fallback from Llama 3.3 70B to Qwen 3 32B or DeepSeek V3.2 often requires only a string change in the model parameter.
Streaming. For real-time dashboards, use streaming responses to render partial results while the request completes.

Conclusion

Building a sentiment analysis tool with an LLM is no longer a research project. With a structured prompt, the OpenAI SDK, and a compatible provider, you can deploy a production classifier in minutes. Oxlo.ai fits this workflow naturally: drop in your existing SDK code, choose from a broad model catalog, and benefit from flat per-request pricing that stays predictable as your text volume grows. For teams processing high volumes of variable-length content, that cost structure makes Oxlo.ai a strong option worth evaluating.

DEV Community