Use Ling-3.0-flash through Novita AI’s OpenAI-compatible chat completions API with the model ID inclusionai/ling-3.0-flash. If you want the shortest working path, create a Novita API key, send requests to https://api.novita.ai/openai/v1/chat/completions, and start with one small text request before adding tools or longer agent loops. This guide stays at the integration layer: setup, request shape, function calling, reasoning controls, and a practical pattern for agentic inference evaluation. For broader launch context and catalog positioning, see Ling-3.0-flash on Novita AI: Free API for Agentic Inference.
What You Need Before the First Request
You only need four values to call Ling-3.0-flash on Novita AI:
| Item | Value |
|---|---|
| API key | A Novita AI API key stored in an environment variable such as NOVITA_API_KEY |
| OpenAI-compatible base URL | https://api.novita.ai/openai |
| Chat completions endpoint | POST https://api.novita.ai/openai/v1/chat/completions |
| Model ID | inclusionai/ling-3.0-flash |
Novita’s LLM API guide documents the OpenAI-compatible base URL and integration pattern, and the chat completions reference documents the request fields used in the examples below.
Export your key locally before testing:
export NOVITA_API_KEY="your_api_key"If your application already uses the OpenAI Python SDK, migration is minimal. Keep your client code, point base_url to Novita AI, and change the model name to inclusionai/ling-3.0-flash.
Before You Move Past the First Request
This guide is intentionally implementation-first, so it does not repeat the full launch breakdown for pricing, architecture, or model comparisons. Before you wire Ling-3.0-flash into production, check three live sources directly:
- The Ling-3.0-flash model page for the exact model ID, supported features, and current output limits.
- The Novita AI pricing page for any pricing changes, especially if the current free window ends.
- The Novita AI rate-limits guide for current tier-based RPM and TPM limits and the expected
429behavior.
That is enough context for a quick start. Once your first request works, validate real prompts, retries, latency, and tool-call behavior against the live limits on your account tier.
cURL Quick Start
Start with one short text request. This validates authentication, model routing, and response parsing before you add tool schemas or larger prompts.
curl "https://api.novita.ai/openai/v1/chat/completions" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${NOVITA_API_KEY}" \
-d '{
"model": "inclusionai/ling-3.0-flash",
"messages": [
{
"role": "system",
"content": "You are a concise engineering assistant."
},
{
"role": "user",
"content": "List three failure modes to test in a tool-calling customer support agent."
}
],
"max_tokens": 256,
"temperature": 0.2
}'If the request succeeds, you should receive a standard chat completions response with:
- a
choicesarray, choices[0].message.content,- a
finish_reason, - and a
usageobject for prompt and completion tokens.
That first smoke test should answer four practical questions:
- Is the API key valid?
- Is the
Authorization: Bearerheader formatted correctly? - Is
inclusionai/ling-3.0-flashaccepted by the endpoint? - Can your client read the assistant message and token usage fields?
Python Quick Start
The OpenAI Python SDK works with Novita AI when you set the Novita base URL.
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="inclusionai/ling-3.0-flash",
messages=[
{"role": "system", "content": "You are a concise engineering assistant."},
{
"role": "user",
"content": "Summarize the release risks of migrating an internal search service to a new vector index.",
},
],
max_tokens=512,
temperature=0.2,
)
print(response.choices[0].message.content)
print("Finish reason:", response.choices[0].finish_reason)
print("Total tokens:", response.usage.total_tokens)For production use, log response.usage from the start. Even when the model is currently free, token usage still matters because it affects latency, rate-limit headroom, and future cost if the promotion ends.
If you need streaming output, set stream=True and iterate over chunks:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/openai",
api_key=os.environ["NOVITA_API_KEY"],
)
stream = client.chat.completions.create(
model="inclusionai/ling-3.0-flash",
messages=[
{"role": "user", "content": "Draft a rollback checklist for a failed production deployment."}
],
max_tokens=512,
temperature=0.2,
stream=True,
)
for chunk in stream:
delta = chunk.choices[0].delta.content
if delta:
print(delta, end="")Key Request Fields That Matter in Practice
Novita’s chat completions API supports the familiar OpenAI-style payload, but not every field matters equally in a real Ling-3.0-flash integration.
| Field | Why you should care |
|---|---|
model | Must be inclusionai/ling-3.0-flash for this guide. |
messages | Carries your system instructions, user input, and prior turns. |
max_tokens | Caps generated output. Set it explicitly. |
temperature | Lower values such as 0.1 to 0.3 work better for agent planning, tool arguments, and code-adjacent tasks. |
stream | Useful for long answers or interactive UX. |
tools | Enables function calling for agent workflows. |
tool_choice | Lets the model decide or forces a specific tool. |
enable_thinking | Exposes the model’s reasoning mode when supported. |
separate_reasoning | Returns reasoning separately from the final answer when supported. |
The main operational rule is simple: start small. Validate a short text request first, then add one advanced feature at a time. Do not try to introduce streaming, tools, long-context prompts, and reasoning controls in the same first test.
Function Calling for Agentic Workflows
Ling-3.0-flash is positioned for agentic inference, so function calling is one of the first features worth testing. Use it when the model should choose an action and return structured arguments instead of answering only in prose.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/openai",
api_key=os.environ["NOVITA_API_KEY"],
)
tools = [
{
"type": "function",
"function": {
"name": "search_runbooks",
"description": "Search incident runbooks for relevant remediation steps.",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "The operational problem to search for."
},
"service": {
"type": "string",
"description": "Optional service name, such as payments-api or worker-cluster."
}
},
"required": ["query"]
}
}
}
]
response = client.chat.completions.create(
model="inclusionai/ling-3.0-flash",
messages=[
{"role": "system", "content": "You are an incident response assistant."},
{
"role": "user",
"content": "Our queue workers are timing out after a Redis failover. Find the most relevant runbook."
},
],
tools=tools,
tool_choice="auto",
max_tokens=512,
temperature=0.1,
)
message = response.choices[0].message
if message.tool_calls:
for call in message.tool_calls:
print(call.function.name)
print(call.function.arguments)
else:
print(message.content)For early evaluation, judge function calling on practical criteria:
- Does the model pick the right tool?
- Are the generated arguments complete and well-typed?
- Does it ask for missing information when the request is ambiguous?
- Does it recover cleanly after a tool error or empty result?
Those behaviors matter more than one impressive demo prompt.
Reasoning Controls
Novita’s current chat completions reference includes enable_thinking and separate_reasoning fields. Because Ling-3.0-flash is listed with reasoning support, they are worth testing in a controlled way on your own workload.
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="inclusionai/ling-3.0-flash",
messages=[
{"role": "system", "content": "You are a careful debugging assistant."},
{
"role": "user",
"content": "A background job now runs twice after a deploy. Propose the most likely root causes."
},
],
enable_thinking=True,
separate_reasoning=True,
max_tokens=700,
temperature=0.2,
)
print(response.choices[0].message)Use this mode selectively. If your application only needs a direct answer or a tool call, extra reasoning output may add latency or complicate downstream parsing. Reasoning controls are most useful when you are measuring task quality, debugging agent decisions, or comparing prompt strategies during evaluation.
A Practical Agentic Inference Pattern
For Ling-3.0-flash, a good first agentic pattern is:
- Run a short text-only smoke test.
- Add one tool with a narrow schema.
- Test five to ten real tasks from your workload.
- Measure completion quality, latency, retries, and tool-call accuracy.
- Only then expand to longer prompts, more tools, or reasoning mode.
That sequence matters because Ling-3.0-flash is attractive precisely for repeated agent loops. A model that looks cheap or capable on one prompt can still fail operationally if it chooses the wrong tool, over-generates arguments, or struggles with partial tool results.
Typical Ling-3.0-flash evaluation scenarios include:
- repository triage and issue classification,
- support workflows that look up policy or account data,
- long-context document review with tool-assisted extraction,
- and orchestration tasks where one request fans out into several model turns.
If the model performs well in those traces, you have better evidence than a benchmark screenshot or a parameter-count comparison.
Common Integration Mistakes
The most common mistakes are operational, not conceptual:
- Using the wrong base URL. For OpenAI-compatible calls, use
https://api.novita.ai/openai. - Forgetting the exact model ID. Use
inclusionai/ling-3.0-flash, not just the display name. - Omitting
max_tokens. Always cap output intentionally. - Sending a huge first prompt. Start small so you can isolate auth, routing, and parsing issues.
- Treating the current free price as permanent. Re-check live pricing before production commitment.
- Adding multiple advanced features at once. Validate text-only, then tools, then reasoning, then long context.
A final practical point: Ling-3.0-flash currently lists text input and text output only on Novita AI. If your workflow needs image or audio input, choose another hosted model rather than trying to stretch this one past its current modality boundary.
FAQ
What is the correct Ling-3.0-flash model ID?
Use inclusionai/ling-3.0-flash in your API requests. That is the exact model ID shown on the current Novita AI model page.
What endpoint should I use for Ling-3.0-flash?
Use the OpenAI-compatible chat completions endpoint:
POST https://api.novita.ai/openai/v1/chat/completionsIf you use an SDK that accepts a base URL, set it to https://api.novita.ai/openai.
Does Ling-3.0-flash support function calling?
Yes. Novita AI currently lists function calling as a supported feature, and this quick start includes a tools example you can adapt for agent workflows.
Does Ling-3.0-flash support reasoning controls?
Yes. The current Novita AI listing includes reasoning support, and the chat completions API reference includes reasoning-related fields such as enable_thinking and separate_reasoning. Test those controls on your own workload before relying on them in production.
What context window does Ling-3.0-flash support?
The current Novita AI model page lists a 262,144-token context window. Check the live model page again before production rollout in case hosted limits change.
Is Ling-3.0-flash text-only on Novita AI?
For the current hosted API, yes. The model listing shows text input and text output, so choose another hosted model if your workflow requires image or audio input.
