Tools

Every Wire container ships with 5 tools. These are the same 5 tools on every container, regardless of how much data is inside or what types of content you’ve added.

Tool	Purpose
wire_explore	Structured canonical access: schema, list, get, filter, text search
wire_search	Fuzzy hybrid retrieval over raw content
wire_navigate	Raw content traversal: siblings, source, relationships
wire_write	Save an entry to the container
wire_delete	Remove an entry by ID

Ephemeral containers also have wire_claim for converting to a permanent container. Analysis runs passively on a per-container cadence (Wire / Scheduled / Manual) configurable in the dashboard — there is no agent-triggered analyze tool in production.

The typical agent journey is explore → search → navigate: use wire_explore to discover what’s in the container and fetch specific rows, use wire_search when you have a question and need fuzzy retrieval across raw content to find the right starting point, and use wire_navigate to move around from a content entry you’ve already landed on.

wire_explore

Structured canonical access. Discover what’s in the container (schema mode, the default), or query classified canonical entries directly by id, field, or keyword.

wire_explore operates on canonical entries — the classified knowledge-graph rows produced by background analysis. For fuzzy/semantic retrieval over raw content (file chunks, agent writes), use wire_search instead.

Parameter	Type	Required	Description
mode	string	No	schema (default), list, get, filter, or text
entityType	string	Required for list, get, filter; optional for text	Entity type to query. In schema mode, drills into detail.
id	string	get only	Canonical row id
query	string	text only	FTS5 query string
filters	array	filter only	Field predicates joined with AND. Operators: eq, neq, gt, gte, lt, lte, contains, in
source	string	No	For list/filter/text — restrict to entries whose source matches or starts with this string (e.g. "file:customers.csv")
fields	string[]	No	Return only these fields (projection)
include	string[]	No	Related entity types to include. Use schema mode to see available relationships.
orderBy	object	No	Sort by field and direction
limit	number	No	Max results (default 100, max 1000)
offset	number	No	Pagination offset
includeSamples	boolean	No	Schema mode only: include sample rows when entityType is given
sampleLimit	number	No	Schema mode only: number of samples (1-10, default 3)

Modes

schema (default) — Discover what’s in the container. Without entityType, returns all entity types with field names, record counts, and relationship edges. With entityType, drills into one type for fields, samples, and availableInclude.

list — Browse records of an entity type with pagination.

get — Retrieve a single record by id. Also returns mentions (text entries that reference this record) and parts (constituent chunks for composite entries). When the entity type is _composite with _compositeType: 'file' (the system-created entry for every uploaded file), the response includes a resource_link pointing at the file’s wire:// URI — agents resolve it via resources/read to get a signed download URL. _composite also represents chunked agent writes and, in the future, scraped webpages and API datasets (distinguished by _compositeType). See File downloads (Resources).

filter — Find records matching field conditions.

text — FTS5 BM25 keyword search across canonical entries. If entityType is provided, searches within that type. If omitted, runs a cross-entity-type search across all canonicals — each result carries its _entityType inline.

Example: NPS survey data

After uploading a CSV and letting background analysis classify the rows:

What kind of data is in this container?

The agent calls wire_explore with no parameters. Wire returns all entity types, their field names, and record counts.

Show me the fields and a few examples from the NPS Responses.

The agent calls wire_explore with entityType: "NPS Response" and includeSamples: true.

Show me all detractor responses from Enterprise customers.

The agent calls wire_explore with mode: "filter", entityType: "NPS Response", and filters for Category = "Detractor" and Plan = "Enterprise".

Which responses mention onboarding anywhere?

The agent calls wire_explore with mode: "text", entityType: "NPS Response", query: "onboarding".

wire_search

Fuzzy hybrid retrieval over raw content in the container — file chunks, agent writes, and other unstructured entries. Always runs a hybrid pipeline: BM25 + vector embedding + HyDE + LLM rerank.

Use this when you have a question and need semantic search to find relevant passages. For structured lookups on classified entities (by id, field, or keyword), use wire_explore.

Flat 5 credits per call.

Parameter	Type	Required	Description
query	string	Yes	Free-text query
topK	number	No	Max results (default 5, max 100)
fileIds	string[]	No	Filter to specific files
minScore	number	No	Minimum similarity score 0-1 (post-rerank)

Each match includes _meta.wire.navigate affordance hints telling the agent what a wire_navigate call on this match would find. See the return shape below for the full structure.

Example

Find any feedback mentioning pricing concerns.

The agent calls wire_search with query: "pricing concerns". This finds entries using phrases like “too expensive” or “not worth the cost” even without the word “pricing.”

Return shape

Each match carries:

• id — the entry uuid. Pass this directly to wire_navigate or wire_delete.
• score — hybrid relevance score (post-rerank).
• content — the raw chunk or entry text.
• provenance — typed metadata object: source, sourceFileId, chunkIndex, totalChunks, ingestedAt, tags, fileName, sectionHeader, chunkSummary, and more. Read the fields directly, no parsing needed.
• _meta.wire.navigate — affordance hints for wire_navigate:
  • hasSiblings — count of adjacent chunks in the same source file. Zero means this chunk stands alone.
  • relationshipTypes — map of edge type to count, only non-zero entries. Example: { "elaborates": 3, "corroborates": 1 }. Tells the agent upfront which wire_navigate mode: "relationships" type: ... calls would find something.

Use these hints to decide whether a wire_navigate call is worth making, and to calibrate range or limit params.

wire_navigate

Traverse raw content from a match returned by wire_search. Given a non-canonical entry id, move to adjacent chunks, to the full source set, or along relationship edges.

wire_navigate is raw-only — it doesn’t cross into canonicals. To reach classified entities (Person, Product, Company, etc.) use wire_explore. Flat 1 credit per call.

Parameter	Type	Required	Description
from	string	Yes	Entry id of a non-canonical content entry (e.g. a wire_search match id)
mode	string	Yes	siblings, source, or relationships
range	number	siblings only	Chunks before AND after the anchor (default 3)
limit	number	source only	Max results (default 50)
offset	number	source only	Pagination offset
type	string	relationships only	Filter by edge type: contradicts, corroborates, elaborates, supersedes, etc. Omit to return all edges.
since	string	No	Lower bound on created_at. ISO timestamp or relative duration (1h, 24h, 7d, 30m, 1w)
before	string	No	Upper bound on created_at
sort	string	No	relevance (default) or chronological (newest first)

Modes

siblings — adjacent chunks in the same source file. Positional navigation. Given a chunk from a file, returns range chunks before and range chunks after it. If the anchor has no chunk position, degrades to source mode with limit = range * 2.

source — all entries from the same source. Paginated. Useful for “what else is in this file / session / webhook payload.” When the anchor’s source is an uploaded file, the response also includes a resource_link content entry pointing at the file’s wire:// URI — agents can call resources/read on it to grab the original bytes. See File downloads (Resources).

relationships — follow entry_relationships edges. Each result includes:

• edgeType — the relationship label (contradicts, corroborates, elaborates, supersedes, derived_from, part_of, mentions).
• edgeDirection — "outgoing" means “anchor edgeType other” (the anchor is the source of the relationship). "incoming" means “other edgeType anchor” (the anchor is on the receiving end). The direction matters because labels are stored from the new entry’s perspective at classification time, so “my chunk contradicts X” and “X contradicts my chunk” are different statements.
• edgeProperties — any metadata attached to the edge itself.

The primary consumer of relationship edges populated by analysis and by per-write pairwise classification.

Temporal filters

since / before / sort combine with each mode’s native filters — they intersect, not substitute. For example siblings with since: "24h" returns adjacent chunks that were also created in the last 24 hours.

Common use case: “what’s new since my last session?” for agents reconnecting to a container after a gap.

Example

After a wire_search call returns a chunk of a pricing document, the agent can:

• Fetch surrounding context: wire_navigate({ from: chunkId, mode: "siblings", range: 3 })
• Read the full document: wire_navigate({ from: chunkId, mode: "source" })
• Find contradictions: wire_navigate({ from: chunkId, mode: "relationships", type: "contradicts" })
• Only recent material: wire_navigate({ from: chunkId, mode: "source", since: "7d" })

Return shape

Each result carries the same typed provenance object as a wire_search match (source, sourceFileId, chunkIndex, ingestedAt, tags, and more), so agents can reason about search results and navigate results the same way. In relationships mode, each result also carries edgeType, edgeDirection, and edgeProperties as described above.

wire_write

Save an entry to the container.

Parameter	Type	Required	Description
content	string or object	Yes	The entry content. Strings are stored as text. Objects are stored as structured data.
tags	string[]	No	Tags for categorization and filtering
metadata	object	No	Arbitrary key-value metadata
source	string	No	Where this entry came from. Defaults to "agent:mcp".

Example usage:

Save a note about the customer meeting with Acme Corp today.
They want to upgrade to Enterprise and need SSO support.

The agent calls wire_write with the meeting notes as content, tagged with ["meeting", "acme-corp"].

wire_delete

Remove an entry by its ID.

Parameter	Type	Required	Description
entryId	string	Yes	The ID of the entry to delete

wire_claim

Generate a claim link for an ephemeral container. Takes no parameters. Returns a URL that the user can open in a browser to sign up or log in and claim the container permanently.

Claim links are short-lived. Call wire_claim again to generate a new one if needed.

This tool only appears on ephemeral containers (created via instant onboarding). Once a container is claimed and belongs to a permanent organization, wire_claim is no longer listed.

Example usage:

I want to keep this container. Can you generate a claim link?

The agent calls wire_claim and returns a URL. The user opens it, signs up or logs in, and the container is moved into their organization.

Note

On public containers, unauthenticated visitors only see read-only tools: wire_explore, wire_search, and wire_navigate. Write and claim tools (wire_write, wire_delete, wire_claim) are hidden. Authenticated users see all tools regardless of container visibility.

Activating and Deactivating Tools

You can activate or deactivate individual tools from the container settings in the Wire dashboard. Inactive tools are hidden from MCP clients and blocked from execution across both MCP and REST API.

Next Steps

• Core Concepts - Learn about entries and containers
• MCP Overview - How to connect and use tools