Integrations

Cursor (MCP) recommended

Best for: developers who want yatabase as a tool inside their IDE chat.

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "yatabase": {
      "url": "https://yatabase.gftd.ai/mcp",
      "headers": {
        "Authorization": "Bearer sk_live_yata_…"
      }
    }
  }
}

Restart Cursor. The 8 yata.* tools (cypher, sparql, storage list/read/write, mcp call) appear in Composer.

Continue.dev

Same as Cursor — vendor-neutral MCP client.

{
  "tools": [{
    "type": "mcp",
    "url": "https://yatabase.gftd.ai/mcp",
    "headers": {"Authorization":"Bearer sk_live_yata_…"}
  }]
}

Claude Desktop / Anthropic MCP clients

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS):

{
  "mcpServers": {
    "yatabase": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://yatabase.gftd.ai/mcp",
               "--header", "Authorization:Bearer sk_live_yata_…"]
    }
  }
}

LangChain (Python)

Best for: backend agents written in Python.

# pip install langchain-mcp-adapters
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
  "yatabase": {
    "transport": "streamable_http",
    "url": "https://yatabase.gftd.ai/mcp",
    "headers": {"Authorization": "Bearer sk_live_yata_…"},
  }
})
tools = await client.get_tools()
# Pass `tools` to any LangChain agent (create_react_agent, etc.)

OpenAI tool calling

For raw OpenAI Chat Completions / Responses API. Use the OpenAPI spec to autogenerate function schemas.

# pip install openapi-pydantic
import requests, json
spec = requests.get("https://yatabase.gftd.ai/openapi.json").json()
# Convert each operation in spec['paths'] to an OpenAI
# function spec via your favorite openapi→tool converter,
# or use the MCP path above (simpler).

TypeScript client (typed)

Generate a fully-typed fetch client from the OpenAPI spec.

npx openapi-typescript https://yatabase.gftd.ai/openapi.json -o yatabase.d.ts

// then in code:
import createClient from "openapi-fetch";
import type { paths } from "./yatabase";

const yata = createClient({
  baseUrl: "https://yatabase.gftd.ai",
  headers: { Authorization: `Bearer ${process.env.YATA_KEY}` },
});
const { data } = await yata.POST("/cypher", {
  body: { query: "MATCH (n:Demo) RETURN n" }
});

Postman

Import the OpenAPI spec — Postman generates a collection automatically.

File → Import → Link → https://yatabase.gftd.ai/openapi.json

Or via CLI: postman api create --workspace=<ws> --schema=https://yatabase.gftd.ai/openapi.json.

Python client

pip install openapi-python-client
openapi-python-client generate \
  --url https://yatabase.gftd.ai/openapi.json

Output: an installable package with typed dataclasses for every request / response in the spec.

S3-compatible tooling (boto3 / aws-cli / rclone)

Use the awsAccessKeyId+secret returned by POST /auth/v1/signup.

aws configure set endpoint_url https://yatabase.gftd.ai/s3
aws s3 cp localfile.txt s3://my-bucket/file.txt
rclone copy localfile.txt yatabase:my-bucket/

Neo4j drivers (read-only Cypher subset)

Use POST /cypher directly — Neo4j HTTP API shape.

curl -X POST https://yatabase.gftd.ai/cypher \
  -H "Authorization: Bearer sk_live_yata_…" \
  -d '{"query":"MATCH (n) RETURN n LIMIT 10"}'

Bolt protocol (:7687) is on the roadmap (P11). Until then, the HTTP path is fully supported.

AT Protocol / Bluesky

Yatabase auth resolves AT Protocol session JWTs as well as sk_live_yata_*.

# Sign in at atproto.gftd.ai, get a session JWT,
# then use the same Bearer header on yatabase.gftd.ai.
curl -H "Authorization: Bearer <at-jwt>" \
  https://yatabase.gftd.ai/api/plan

raw curl

For shell scripts, CI, or just getting things done.

# 1. Mint a key (anonymous)
KEY=$(curl -sS -X POST https://yatabase.gftd.ai/auth/v1/signup \
       | jq -r .apiKey)

# 2. First Cypher query
curl -X POST https://yatabase.gftd.ai/cypher \
  -H "Authorization: Bearer $KEY" \
  -d '{"query":"CREATE (n:Hello) RETURN n"}'