Detects the source
Give it a URL or paste raw text. Woes recognizes OpenAPI, GraphQL, AsyncAPI, Postman, gRPC, SOAP/WSDL, docs, and SDK examples.
Context ingestion
Your API becomes context
Point Woes at an OpenAPI spec, a docs site, or raw schema text. It crawls, parses, chunks, and embeds every endpoint into workspace-scoped context the agent can cite.
OpenAPI · GraphQL · docsEndpoint MarkdownEmbedded & searchable
01
fetch
safe crawl
02
detect
API family
03
normalize
endpoint.md
04
embed
searchable
docs.acme.dev/openapi.json128 endpoints512 chunks embedded
The problem
Your answers are only as good as your context
Your API truth is scattered across an OpenAPI file, a docs site, a Postman collection, and a folder of SDK snippets. Support agents — human or AI — can't answer accurately from documentation they can't search. Copy-pasting specs into a chatbot doesn't scale, and it goes stale the moment your API changes.
Why it works
The agent is only as grounded as the context behind it.
Normalizes to endpoints
Operations become clean endpoint Markdown — method, path, params, auth, and responses — so retrieval returns something the agent can cite.
Honest coverage
Ingestion is idempotent and reports real counts — endpoints, documents, and chunks — plus partial coverage when a source is incomplete.
Endpoints, normalized
Your API, rendered as evidence
Every operation is normalized into clean endpoint Markdown — method, path, params, auth, responses — then chunked and embedded. Retrieval returns something the agent can actually cite.
endpoint.md embedded
GET /v1/orders/{id}
# auth Bearer · scoped per env
# params id: string (required)
# responses 200 · 401 · 404
Ingest
One importer for every API format
Woes fetches safely, detects the API family, and parses it into a normalized shape. A docs site is crawled within same-origin rules; a spec is parsed operation by operation; raw text is classified and structured. Payload limits and safe-fetch rules keep the crawl bounded.
- OpenAPI, GraphQL, AsyncAPI, Postman, gRPC, SOAP/WSDL
- Docs URLs, raw schema text, and SDK examples
- Same-origin crawl rules and payload limits
one importer · every format
Normalize
Endpoints in, searchable evidence out
Each operation is normalized into endpoint Markdown — method, path, parameters, auth expectations, and response shapes — then chunked and embedded into workspace-scoped context. When embeddings are unavailable, ingestion falls back gracefully rather than failing the source.
- Method, path, params, auth, and responses per endpoint
- Chunked and embedded for semantic retrieval
- Graceful embeddings fallback on provider failure
endpoint.md · normalized
Verify
You always know what got covered
Ingestion tells the truth about coverage. You see endpoint, document, and chunk counts, partial-coverage flags when a source is incomplete, and idempotent re-runs that update rather than duplicate. Nothing is silently dropped.
- Live endpoint, document, and chunk counts
- Partial-coverage flags on incomplete sources
- Idempotent re-ingestion — update, don't duplicate
coverage · honest counts
How it works
Three steps, no heavy lift.
01step
Add a source
Paste a spec, upload raw schema text, or point Woes at a docs URL.
source · docs.acme.dev/openapi.json
02step
Parse and normalize
Woes detects the family, extracts operations, and writes endpoint Markdown.
128 endpoints · 512 chunks
03step
Embed and publish
Chunks are embedded into workspace-scoped context, ready for grounded retrieval.
embedded → searchable context
8+
API source formats
auto
source detection
0
silent drops
FAQ
API context ingestion questions
What API formats can Woes ingest?
OpenAPI, GraphQL, AsyncAPI, Postman collections, gRPC, and SOAP/WSDL, plus documentation URLs, raw schema text, and SDK examples. Woes detects the source type automatically.
What happens when a docs site is large or partly unreachable?
Crawling follows same-origin rules and payload limits, and ingestion reports partial coverage honestly with real counts instead of pretending a source is complete.
Do re-imports create duplicates?
No. Ingestion is idempotent — re-running a source updates existing context rather than duplicating it, so counts stay accurate.
What if embeddings fail?
Ingestion falls back gracefully so a provider hiccup doesn't fail the whole source. The context is still stored and made available for retrieval.
Turn your API surface into context
Ingest your specs and docs once and give every channel a grounded, searchable source of truth.