Provider Markdown Export

Copy the complete documentation for a specific provider as a single Markdown file.

Export complete provider-specific documentation as a single Markdown file. Useful for pasting into LLMs, internal wikis, or offline reference.

Preview: Snowflake Markdown

# Embedd.to — Snowflake Integration Guide

## Overview

Embedd.to connects to your Snowflake database, automatically generates and maintains vector embeddings, and provides a unified query API for semantic search.

Snowflake supports both **managed mode** (vectors in Qdrant) and **platform mode** (vectors in your Snowflake database).

## Authentication

All requests require:
- `Authorization: Bearer sk_your_api_key` header
- `X-Environment-Id: env_...` header

## Step 1: Create a Connection

```bash
curl -X POST https://api.embedd.to/v1/providers/snowflake/connections \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-snowflake",
    "mode": "managed",
    "credentials": {
      "auth_method": "password",
      "account": "myorg-account",
      "user": "EMBEDD_USER",
      "password": "secure_password",
      "warehouse": "COMPUTE_WH",
      "database": "ANALYTICS",
      "schema": "PUBLIC",
      "role": "EMBEDD_ROLE"
    }
  }'
```

### Snowflake Credentials

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| auth_method | string | Yes | `password` or `key_pair` |
| account | string | Yes | Snowflake account identifier |
| user | string | Yes | Username |
| password | string | Conditional | Required for password auth |
| private_key | string | Conditional | PEM-encoded key for key_pair auth |
| warehouse | string | No | Warehouse name |
| database | string | No | Database name |
| schema | string | No | Schema name (default: PUBLIC) |
| role | string | No | Role name |

### Required Permissions

```sql
GRANT USAGE ON DATABASE ANALYTICS TO ROLE EMBEDD_ROLE;
GRANT USAGE ON SCHEMA ANALYTICS.PUBLIC TO ROLE EMBEDD_ROLE;
GRANT SELECT ON TABLE ANALYTICS.PUBLIC.PRODUCTS TO ROLE EMBEDD_ROLE;
-- For platform mode:
GRANT CREATE TABLE ON SCHEMA ANALYTICS.PUBLIC TO ROLE EMBEDD_ROLE;
```

## Step 2: Test the Connection

```bash
curl -X POST https://api.embedd.to/v1/connections/{connection_id}/test \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123"
```

## Step 3: Register an Embedding Provider (Managed Mode)

For managed mode, register an embedding provider. For platform mode with Cortex, skip this step.

```bash
curl -X POST https://api.embedd.to/v1/embedding-providers \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-openai",
    "provider": "openai",
    "api_key": "sk-proj-...",
    "default_model": "text-embedding-3-small"
  }'
```

## Step 4: Create a Vector Table

### Managed Mode (vectors in Qdrant)

```bash
curl -X POST https://api.embedd.to/v1/vector-tables \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "product-search",
    "connection_id": "conn_abc123",
    "embedding_provider_id": "ep_abc123",
    "source_table": "PRODUCTS",
    "primary_key_column": "ID",
    "columns": [
      {"name": "DESCRIPTION", "role": "embedding", "ordinal": 1},
      {"name": "CATEGORY", "role": "metadata", "filter_type": "keyword"},
      {"name": "PRICE", "role": "metadata", "filter_type": "float"}
    ],
    "embedding_model": "text-embedding-3-small",
    "embedding_dimensions": 1536,
    "mode": "managed",
    "sync_mode": "cdc"
  }'
```

### Platform Mode with Cortex (vectors in Snowflake)

```bash
curl -X POST https://api.embedd.to/v1/vector-tables \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "product-search",
    "connection_id": "conn_abc123",
    "source_table": "PRODUCTS",
    "primary_key_column": "ID",
    "columns": [
      {"name": "DESCRIPTION", "role": "embedding", "ordinal": 1},
      {"name": "CATEGORY", "role": "metadata", "filter_type": "keyword"}
    ],
    "embedding_model": "snowflake-arctic-embed-m-v1.5",
    "embedding_dimensions": 768,
    "mode": "platform",
    "sync_mode": "cdc"
  }'
```

Cortex models: `snowflake-arctic-embed-m-v1.5` (768d), `snowflake-arctic-embed-l-v2.0` (1024d).

## Step 5: Trigger Backfill

```bash
curl -X POST https://api.embedd.to/v1/vector-tables/{vector_table_id}/backfill \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123"
```

## Step 6: Query

```bash
curl -X POST https://api.embedd.to/v1/vector-tables/{vector_table_id}/query \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "comfortable running shoes",
    "limit": 5,
    "filters": {
      "CATEGORY": {"$eq": "footwear"},
      "PRICE": {"$lte": 150}
    }
  }'
```

## Snowflake Filter Translation

| Filter | Snowflake SQL |
|--------|--------------|
| `$eq` | `metadata:field = 'value'` |
| `$ne` | `metadata:field != 'value'` |
| `$gt` | `metadata:field > value` |
| `$gte` | `metadata:field >= value` |
| `$lt` | `metadata:field < value` |
| `$lte` | `metadata:field <= value` |
| `$in` | `metadata:field IN (...)` |
| `$nin` | `metadata:field NOT IN (...)` |
| `$exists` | `metadata:field IS [NOT] NULL` |

## Sync Control

```bash
# Check sync status
curl https://api.embedd.to/v1/vector-tables/{id}/sync/status

# Pause sync
curl -X POST https://api.embedd.to/v1/vector-tables/{id}/sync/pause

# Resume sync
curl -X POST https://api.embedd.to/v1/vector-tables/{id}/sync/resume
```

## Platform Mode Vector Table Schema

```sql
CREATE TABLE EMBEDD_VT_xxxxxxxx_name (
    PK_VALUE VARCHAR,
    EMBEDDING VECTOR(FLOAT, 1536),
    EMBEDDED_TEXT VARCHAR,
    METADATA VARIANT,
    ROW_HASH VARCHAR,
    PRIMARY KEY (PK_VALUE)
);
```

Preview: PostgreSQL Markdown

# Embedd.to — PostgreSQL Integration Guide

## Overview

Embedd.to connects to your PostgreSQL database, automatically generates and maintains vector embeddings, and provides a unified query API for semantic search.

PostgreSQL supports both **managed mode** (vectors in Qdrant) and **platform mode** (vectors in your PostgreSQL database using pgvector).

## Authentication

All requests require:
- `Authorization: Bearer sk_your_api_key` header
- `X-Environment-Id: env_...` header

## Step 1: Create a Connection

```bash
curl -X POST https://api.embedd.to/v1/providers/postgresql/connections \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-postgres",
    "mode": "managed",
    "credentials": {
      "host": "db.example.com",
      "port": 5432,
      "database": "mydb",
      "user": "embedd_user",
      "password": "secure_password",
      "ssl_mode": "require"
    }
  }'
```

### PostgreSQL Credentials

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| host | string | Yes | Database hostname |
| port | integer | No | Port (default: 5432) |
| database | string | Yes | Database name |
| user | string | Yes | Username |
| password | string | Yes | Password |
| ssl_mode | string | No | SSL mode (require, verify-ca, etc.) |

### Required Permissions

```sql
GRANT SELECT ON TABLE products TO embedd_user;
-- For platform mode:
GRANT CREATE ON SCHEMA public TO embedd_user;
CREATE EXTENSION IF NOT EXISTS vector;
```

## Step 2: Test the Connection

```bash
curl -X POST https://api.embedd.to/v1/connections/{connection_id}/test \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123"
```

## Step 3: Register an Embedding Provider

An embedding provider is required for both managed and platform mode (PostgreSQL has no native embedding capability).

```bash
curl -X POST https://api.embedd.to/v1/embedding-providers \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-openai",
    "provider": "openai",
    "api_key": "sk-proj-...",
    "default_model": "text-embedding-3-small"
  }'
```

## Step 4: Create a Vector Table

### Managed Mode (vectors in Qdrant)

```bash
curl -X POST https://api.embedd.to/v1/vector-tables \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "product-search",
    "connection_id": "conn_abc123",
    "embedding_provider_id": "ep_abc123",
    "source_table": "products",
    "primary_key_column": "id",
    "columns": [
      {"name": "description", "role": "embedding", "ordinal": 1},
      {"name": "category", "role": "metadata", "filter_type": "keyword"},
      {"name": "price", "role": "metadata", "filter_type": "float"}
    ],
    "embedding_model": "text-embedding-3-small",
    "embedding_dimensions": 1536,
    "mode": "managed",
    "sync_mode": "cdc"
  }'
```

### Platform Mode (vectors in PostgreSQL with pgvector)

```bash
curl -X POST https://api.embedd.to/v1/vector-tables \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "product-search",
    "connection_id": "conn_abc123",
    "embedding_provider_id": "ep_abc123",
    "source_table": "products",
    "primary_key_column": "id",
    "columns": [
      {"name": "description", "role": "embedding", "ordinal": 1},
      {"name": "category", "role": "metadata", "filter_type": "keyword"}
    ],
    "embedding_model": "text-embedding-3-small",
    "embedding_dimensions": 1536,
    "mode": "platform",
    "sync_mode": "cdc"
  }'
```

**Note:** `embedding_provider_id` is always required for PostgreSQL (both modes).

## Step 5: Trigger Backfill

```bash
curl -X POST https://api.embedd.to/v1/vector-tables/{vector_table_id}/backfill \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123"
```

## Step 6: Query

```bash
curl -X POST https://api.embedd.to/v1/vector-tables/{vector_table_id}/query \
  -H "Authorization: Bearer sk_your_key" \
  -H "X-Environment-Id: env_abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "comfortable running shoes",
    "limit": 5,
    "filters": {
      "category": {"$eq": "footwear"},
      "price": {"$lte": 150}
    }
  }'
```

## PostgreSQL Filter Translation

| Filter | PostgreSQL SQL |
|--------|---------------|
| `$eq` | `metadata->>'field' = 'value'` |
| `$ne` | `metadata->>'field' != 'value'` |
| `$gt` | `(metadata->>'field')::numeric > value` |
| `$gte` | `(metadata->>'field')::numeric >= value` |
| `$lt` | `(metadata->>'field')::numeric < value` |
| `$lte` | `(metadata->>'field')::numeric <= value` |
| `$in` | `metadata->>'field' IN (...)` |
| `$nin` | `metadata->>'field' NOT IN (...)` |
| `$exists` | `metadata ? 'field'` |

## Sync Control

```bash
# Check sync status
curl https://api.embedd.to/v1/vector-tables/{id}/sync/status

# Pause sync
curl -X POST https://api.embedd.to/v1/vector-tables/{id}/sync/pause

# Resume sync
curl -X POST https://api.embedd.to/v1/vector-tables/{id}/sync/resume
```

## Platform Mode Details

### Prerequisites
- PostgreSQL 14+ with pgvector extension installed
- `CREATE EXTENSION IF NOT EXISTS vector;` must be run

### Vector Table Schema
```sql
CREATE TABLE embedd_vt_xxxxxxxx_name (
    pk_value TEXT PRIMARY KEY,
    embedding vector(1536),
    embedded_text TEXT,
    metadata JSONB DEFAULT '{}',
    row_hash TEXT
);
CREATE INDEX ON embedd_vt_xxxxxxxx_name USING hnsw (embedding vector_cosine_ops);
```

### HNSW Iterative Scan
Embedd.to sets `hnsw.iterative_scan = on` for all queries to ensure consistent results with filtered HNSW searches.