Relace Search
Relace Search is a text-only large language model from Relace optimized for agentic multi-step search over large codebases, using parallel file-inspection tools to return highly relevant files quickly.
What is Relace Search?
Relace Search is a Relace large language model designed to explore codebases using 4–12 parallel `view_file` and `grep`-style tools and return the most relevant files to a query. It is mainly used as a subagent in autonomous coding systems to perform high-precision, multi-step search across large repositories, and to feed its findings into an orchestrating “oracle” coding agent. It is also useful for document-heavy workflows that benefit from its 256K-token context window and support for tool use and function calling. Relace Search belongs to Relace’s family of small, fast models built specifically as tools for coding agents and large-codebase retrieval.
Providers
Different companies host the same model. OpenRouter routes your request to one of them based on the routing mode you pick — Balanced (price + speed), Nitro (fastest), or Exacto (highest tool-calling accuracy).
| Provider | Input | Output | Cache read /M | Latency | Throughput | Uptime |
|---|---|---|---|---|---|---|
| Relace | ~$0.10 per 1M queries | $0.00 | — | ~120ms | ~60 qps | ~99.9% |
| Pinecone (similar vector search) | ~$0.20 per 1M queries | $0.00 | — | ~150ms | ~40 qps | 99.9% |
| Weaviate Cloud (similar vector search) | ~$0.18 per 1M queries | $0.00 | — | ~160ms | ~35 qps | ~99.9% |
| Qdrant Cloud (similar vector search) | ~$0.16 per 1M queries | $0.00 | — | ~170ms | ~30 qps | ~99.9% |
Try this model
Test Relace Search right here — free to start.
Suggestions for your first prompt
Code snippet
Call the model through the OpenAI-compatible API.
from openai import OpenAI
client = OpenAI(
api_key="YOUR_API_KEY",
base_url="https://inference.example.com/v1"
)
response = client.chat.completions.create(
model="relace/relace-search",
messages=[
{
"role": "user",
"content": "Describe this image in one sentence."
}
],
)
print(response.to_json())
{
"model": "relace/relace-search",
"messages": [
{
"role": "user",
"content": "Describe this image in one sentence."
}
]
}
5 Core Capabilities
-
Agentic Code Search
Uses multiple parallel view_file and grep tools to explore large codebases and return precisely targeted relevant files.
-
Tool-Aware Orchestration
Acts as a subagent that coordinates with external tools and hands structured findings to a downstream oracle coding agent.
-
Long-Context Retrieval
Handles up to 256K-token contexts, enabling semantic search across extensive repositories, documentation, and multi-file projects.
-
Structured Function Calling
Supports tool use and function calling, enabling programmatic integration into automated pipelines and custom developer workflows.
-
Text-Only Interface
Provides text input and output completions via OpenAI-compatible chat endpoints, without native image or multimodal support.
6 Most Valuable Use Cases
- Codebase File Retrieval
- Agentic Code Search
- Refactor Impact Scoping
- Bug Context Gathering
- Monorepo Navigation Assistant
- Tool-Augmented Code Browsing
Why Build on LLM.API?
One unified API. Every major model. Built-in reliability, cost control, and observability.
-
Unified AI Routing
Automatically route each request to the best model across providers based on latency, capabilities, or custom rules—without changing your code or client integration.
One endpoint, every model -
Cost-Aware Execution
Set cost ceilings and optimization policies so LLM.API chooses the most cost-effective model per call while preserving quality and performance at scale.
Lower spend, same quality -
Resilient Fallbacks
Configure provider and model failover in the platform, not your app. If a model degrades or fails, traffic shifts automatically to healthy alternatives.
No single point of failure -
Deep Observability
Get centralized logs, traces, and metrics for every provider and model: latencies, errors, token usage, and cost, with queryable insights for debugging and optimization.
See every token, everywhere -
Task-Level Abstractions
Define tasks like chat, summarize, extract, or classify once. LLM.API maps them to the right models and prompts so you ship features instead of glue code.
Think tasks, not models -
High-Throughput Batch
Batch thousands of inferences across providers through a single API call, with automatic chunking, retries, and result aggregation tuned for large-scale workloads.
Max throughput, minimal code
When to Use — When NOT to Use
Use it if...
- You need an agent to rapidly locate relevant files across very large codebases.
- You need multi-step, tool-using search that orchestrates parallel view_file and grep calls.
- Your use case involves powering an oracle coding agent with precise code search results.
- You need a code-focused search model with a 256K context and large outputs.
- Your use case involves building custom agent harnesses that parse structured search responses.
- You need OpenAI-compatible API access to specialized code search via platforms like OpenRouter.
Avoid if...
- You need a general-purpose chat or reasoning model beyond code search and retrieval.
- Your workload requires plug-and-play usage without building an agent harness around tools.
- You need the absolute cheapest model for simple keyword search over small repositories.
- Your workload requires vision, audio, or multimodal understanding rather than pure text code search.
- You need high-quality code generation or refactoring, not just finding relevant source files.
- Your workload requires ultra-low-latency single-call responses without parallel tool invocations.
Frequently Asked Questions
-
What is Relace Search?
Relace Search is a search-optimized AI model by Relace designed to retrieve and rank relevant documents over large corpora.
-
What is Relace Search best suited for?
Relace Search is best for semantic search, retrieval-augmented generation backends, and relevance-ranked document or passage search.
-
What modalities does Relace Search support?
Relace Search works with text-only inputs and returns structured text-based results, not images, audio, or video.
-
How is Relace Search priced when used through LLM.API?
Relace Search pricing on LLM.API is usage-based per request or token, and you should check the LLM.API pricing page for current rates.
-
What is the context window of Relace Search?
Relace Search supports a provider-defined maximum query and document length; consult the LLM.API model card for the latest context window limits.
-
How fast is Relace Search in terms of latency?
Relace Search typically responds fast enough for interactive applications, but actual latency depends on corpus size, request complexity, and network conditions.
-
How do I call Relace Search via LLM.API?
You call Relace Search by specifying the Relace Search model name in your LLM.API request and passing your query and optional search parameters.
-
Can I use Relace Search as the retrieval layer for my RAG system?
Yes, you can use Relace Search to retrieve top relevant documents and feed them into a separate generative model for RAG workflows.
-
How does Relace Search compare to general-purpose LLMs for search tasks?
Relace Search is specialized for retrieval relevance and ranking, whereas general-purpose LLMs focus on generation and may be less efficient for large-scale search.
-
What are the main limitations of Relace Search?
Relace Search does not generate long-form answers, relies on the indexed corpus quality, and is limited to text-based search scenarios.
COMPARE
Competitive Models
-
GLM 4.6V
GLM 4.6V is Z.ai’s open-source, large-scale vision-language model that supports images, video, documents, and text with a long context window and native tool use. It is notable for combining high-quality multimodal understanding with function calling and cloud- or local-friendly variants.
-
Gemini 3.1 Flash TTS Preview
Gemini 3.1 Flash TTS Preview is Google’s low-latency text‑to‑speech model that generates natural, expressive speech with fine-grained control via style prompts and audio tags. It is optimized for fast, high‑quality voice synthesis across many languages and voices.
Get one key to every model
Swap your API key. Keep your code.