API Reference

Link: </v1/openapi.json>; rel="service-desc"

GET /v1/openapi.json

GET /v1/live

{
  "status": "ok"
}

GET /v1/health

{
  "status": "healthy",
  "pipelines": [
    {
      "name": "my-docs",
      "embedding": { "reachable": true },
      "completion": { "reachable": true }
    }
  ]
}

{
  "status": "degraded",
  "pipelines": [
    {
      "name": "my-docs",
      "embedding": { "reachable": true },
      "completion": {
        "reachable": false,
        "error": "connection refused"
      }
    }
  ]
}

GET /v1/pipelines

{
  "pipelines": [
    {
      "name": "my-docs",
      "description": "Search my documentation"
    },
    {
      "name": "knowledge-base",
      "description": "Corporate knowledge base"
    }
  ]
}

GET /v1/stats

{
  "pipelines": [
    {
      "name": "my-docs",
      "description": "Search my documentation",
      "embedding": {
        "prompt_tokens": 1024,
        "completion_tokens": 0,
        "total_tokens": 1024
      },
      "completion": {
        "prompt_tokens": 4096,
        "completion_tokens": 512,
        "total_tokens": 4608
      }
    }
  ]
}

POST /v1/pipelines/{name}

{
  "query": "How do I configure replication?",
  "stream": false,
  "top_n": 10,
  "filter": {
    "conditions": [
      {"column": "product", "operator": "=", "value": "pgEdge"},
      {"column": "version", "operator": "=", "value": "v5.0"}
    ],
    "logic": "AND"
  },
  "include_sources": true,
  "messages": [
    {"role": "user", "content": "What is pgEdge?"},
    {"role": "assistant", "content": "pgEdge is a distributed PostgreSQL platform..."}
  ]
}

{
  "conditions": [
    {"column": "product", "operator": "=", "value": "pgAdmin"}
  ]
}

{
  "conditions": [
    {"column": "product", "operator": "=", "value": "pgAdmin"},
    {"column": "version", "operator": ">=", "value": "v8.0"}
  ],
  "logic": "AND"
}

{
  "conditions": [
    {"column": "status", "operator": "=", "value": "published"},
    {"column": "status", "operator": "=", "value": "draft"}
  ],
  "logic": "OR"
}

{
  "answer": "To configure replication, you need to...",
  "tokens_used": 1523
}

{
  "answer": "To configure replication, you need to...",
  "sources": [
    {
      "id": "doc-123",
      "content": "Replication is configured by...",
      "score": 0.95
    },
    {
      "id": "doc-456",
      "content": "The replication settings include...",
      "score": 0.87
    }
  ],
  "tokens_used": 1523
}

Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive

data: {"type": "chunk", "content": "To configure "}

data: {"type": "chunk", "content": "replication, "}

data: {"type": "chunk", "content": "you need to..."}

data: {"type": "done"}

{
  "error": {
    "code": "PIPELINE_NOT_FOUND",
    "message": "pipeline not found: unknown-pipeline"
  }
}

curl http://localhost:8080/v1/pipelines

curl -X POST http://localhost:8080/v1/pipelines/my-docs \
  -H "Content-Type: application/json" \
  -d '{"query": "How do I get started?"}'

curl -X POST http://localhost:8080/v1/pipelines/my-docs \
  -H "Content-Type: application/json" \
  -d '{
    "query": "How do I configure backups?",
    "filter": {
      "conditions": [
        {"column": "product", "operator": "=", "value": "pgAdmin"},
        {"column": "version", "operator": "=", "value": "v9.0"}
      ],
      "logic": "AND"
    }
  }'

curl -X POST http://localhost:8080/v1/pipelines/my-docs \
  -H "Content-Type: application/json" \
  -N \
  -d '{"query": "Explain the architecture", "stream": true}'

import requests

response = requests.post(
    "http://localhost:8080/v1/pipelines/my-docs",
    json={"query": "How do I configure SSL?"}
)

data = response.json()
print(data["answer"])

for source in data["sources"]:
    print(f"- {source['content'][:100]}... (score: {source['score']:.2f})")

import requests

response = requests.post(
    "http://localhost:8080/v1/pipelines/my-docs",
    json={"query": "Explain the setup process", "stream": True},
    stream=True
)

for line in response.iter_lines():
    if line and line.startswith(b"data: "):
        import json
        event = json.loads(line[6:])
        if event["type"] == "chunk":
            print(event["content"], end="", flush=True)
        elif event["type"] == "done":
            print()  # newline at end

const response = await fetch("http://localhost:8080/v1/pipelines/my-docs", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ query: "How do I get started?" }),
});

const data = await response.json();
console.log(data.answer);

// Using fetch for SSE
const response = await fetch("http://localhost:8080/v1/pipelines/my-docs", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ query: "Explain the setup", stream: true }),
});

const reader = response.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  const text = decoder.decode(value);
  const lines = text.split("\n");

  for (const line of lines) {
    if (line.startsWith("data: ")) {
      const event = JSON.parse(line.slice(6));
      if (event.type === "chunk") {
        process.stdout.write(event.content);
      }
    }
  }
}