Create non-linear index

Add a non-linear index (HNSW) to accelerate similarity search on a store.

Every operation works on both Vector DB stores (you supply raw vectors) and AI stores (you supply text or images and Ahnlich AI generates the embeddings for you). Use the Vector DB / AI switch in the sample below.

Parameters

Parameter	Type	Description
store	string	Store to index.
non_linear_indices	list	Index specs — an HnswConfig per index.
schema	string · optional	Schema to target. Defaults to public.

All requests accept an optional schema field. When omitted, the server uses the public schema.

Behavior

• HNSW — approximate nearest-neighbour with a configurable accuracy/speed tradeoff.
• Pre-structuring the data speeds up queries but uses extra memory.

Sample query

Database engine

Python

Python

import asyncio
from grpclib.client import Channel
from ahnlich_client_py.grpc.services.db_service import DbServiceStub
from ahnlich_client_py.grpc.db import query as db_query
from ahnlich_client_py.grpc.algorithm.nonlinear import NonLinearIndex, HnswConfig


async def create_non_linear_algo_index():
  async with Channel(host="127.0.0.1", port=1369) as channel:
      client = DbServiceStub(channel)

      # Create an HNSW index (with optional config)
      response = await client.create_non_linear_algorithm_index(
          db_query.CreateNonLinearAlgorithmIndex(
              store="my_store",
              schema="analytics",
              non_linear_indices=[NonLinearIndex(hnsw=HnswConfig())]
          )
      )
      # response.created_indexes shows how many indexes were created
  print(response)


if __name__ == "__main__":
  asyncio.run(create_non_linear_algo_index())

Node.js

TypeScript

import { createDbClient } from "ahnlich-client-node";
import { CreateNonLinearAlgorithmIndex } from "ahnlich-client-node/grpc/db/query_pb";
import { NonLinearIndex, HNSWConfig } from "ahnlich-client-node/grpc/algorithm/nonlinear_pb";

async function createHNSWIndex() {
  const client = createDbClient("127.0.0.1:1369");

  await client.createNonLinearAlgorithmIndex(
    new CreateNonLinearAlgorithmIndex({
      store: "my_store",
      schema: "analytics",
      nonLinearIndices: [
        new NonLinearIndex({
          index: { case: "hnsw", value: new HNSWConfig() },
        }),
      ],
    })
  );

  console.log("HNSW index created successfully");
}

createHNSWIndex();

Go

Go

package main


import (
    "context"
    "fmt"
    "log"
    "time"


    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"


    dbsvc      "github.com/deven96/ahnlich/sdk/ahnlich-client-go/grpc/services/db_service"
    dbquery    "github.com/deven96/ahnlich/sdk/ahnlich-client-go/grpc/db/query"
    nonlinear  "github.com/deven96/ahnlich/sdk/ahnlich-client-go/grpc/algorithm/nonlinear"
)


const ServerAddr = "127.0.0.1:1369"


func stringPtr(value string) *string { return &value }


type ExampleDBClient struct {
    conn   *grpc.ClientConn
    client dbsvc.DBServiceClient
    ctx    context.Context
}


func NewDBClient(ctx context.Context) (*ExampleDBClient, error) {
    conn, err := grpc.NewClient(ServerAddr, grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        return nil, fmt.Errorf("failed to dial DB server %q: %w", ServerAddr, err)
    }
    client := dbsvc.NewDBServiceClient(conn)
    return &ExampleDBClient{conn: conn, client: client, ctx: ctx}, nil
}


func (c *ExampleDBClient) Close() error {
    return c.conn.Close()
}


func (c *ExampleDBClient) exampleCreateNonLinearAlgoIndex() error {
    // Create an HNSW index (with optional config)
    _, err := c.client.CreateNonLinearAlgorithmIndex(c.ctx, &dbquery.CreateNonLinearAlgorithmIndex{
        Store: "my_store",
        Schema: stringPtr("analytics"), // Optional: defaults to public when omitted
        NonLinearIndices: []*nonlinear.NonLinearIndex{
            {Index: &nonlinear.NonLinearIndex_Hnsw{Hnsw: &nonlinear.HNSWConfig{}}},
        },
    })
    return err
}


func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()


    client, err := NewDBClient(ctx)
    if err != nil {
        log.Fatalf("Failed to create DB client: %v", err)
    }
    defer client.Close()


    if err := client.exampleCreateNonLinearAlgoIndex(); err != nil {
        log.Fatalf("CreateNonLinearAlgoIndex failed: %v", err)
    }
    fmt.Println("Created Non-Linear Algorithm Index for 'my_store'")
}

Rust

Rust

use ahnlich_client_rs::db::DbClient;
use ahnlich_types::db::query::CreateNonLinearAlgorithmIndex;
use ahnlich_types::algorithm::nonlinear::{NonLinearIndex, non_linear_index, HnswConfig};


#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db_client = DbClient::new("127.0.0.1:1369".to_string()).await?;

    // Create an HNSW index on the "my_store" store (with default config)
    let params = CreateNonLinearAlgorithmIndex {
        store: "my_store".to_string(),
        schema: Some("analytics".to_string()),
        non_linear_indices: vec![
            NonLinearIndex {
                index: Some(non_linear_index::Index::Hnsw(HnswConfig::default())),
            },
        ],
    };

    let result = db_client.create_non_linear_algorithm_index(params, None).await?;
    println!("Created non-linear indices: {:?}", result);

    Ok(())
}

CLI

$CREATENONLINEARALGORITHMINDEX (hnsw) IN my_store

AI proxy

Python

Python

import asyncio
from grpclib.client import Channel
from ahnlich_client_py.grpc.services.ai_service import AiServiceStub
from ahnlich_client_py.grpc.ai import query as ai_query
from ahnlich_client_py.grpc.algorithm.nonlinear import NonLinearIndex, HnswConfig


async def create_non_linear_algorithm_index():
  async with Channel(host="127.0.0.1", port=1370) as channel:
      client = AiServiceStub(channel)

      # Create an HNSW index (with optional config)
      response = await client.create_non_linear_algorithm_index(
          ai_query.CreateNonLinearAlgorithmIndex(
              store="my_store",
              schema="analytics",
              non_linear_indices=[NonLinearIndex(hnsw=HnswConfig())],
          )
      )


if __name__ == "__main__":
  asyncio.run(create_non_linear_algorithm_index())

Node.js

TypeScript

import { createAiClient } from "ahnlich-client-node";
import { CreateNonLinearAlgorithmIndex } from "ahnlich-client-node/grpc/ai/query_pb";
import { NonLinearIndex, HNSWConfig } from "ahnlich-client-node/grpc/algorithm/nonlinear_pb";

async function createHNSWIndex() {
  const client = createAiClient("127.0.0.1:1370");

  await client.createNonLinearAlgorithmIndex(
    new CreateNonLinearAlgorithmIndex({
      store: "ai_store",
      schema: "analytics",
      nonLinearIndices: [
        new NonLinearIndex({
          index: { case: "hnsw", value: new HNSWConfig() },
        }),
      ],
    })
  );

  console.log("HNSW index created");
}

createHNSWIndex();

Go

Go

package main


import (
  "context"
  "fmt"
  "log"
  "time"


  "google.golang.org/grpc"
  "google.golang.org/grpc/credentials/insecure"


  aiquery "github.com/deven96/ahnlich/sdk/ahnlich-client-go/grpc/ai/query"
  aisvc "github.com/deven96/ahnlich/sdk/ahnlich-client-go/grpc/services/ai_service"
  nonlinear "github.com/deven96/ahnlich/sdk/ahnlich-client-go/grpc/algorithm/nonlinear"
)


const AIAddr = "127.0.0.1:1370"


// ExampleAIClient wraps the connection + AIService client
func stringPtr(value string) *string { return &value }


type ExampleAIClient struct {
  conn   *grpc.ClientConn
  client aisvc.AIServiceClient
  ctx    context.Context
}


// NewAIClient connects to the AI server
func NewAIClient(ctx context.Context) (*ExampleAIClient, error) {
  conn, err := grpc.DialContext(ctx, AIAddr,
      grpc.WithTransportCredentials(insecure.NewCredentials()),
      grpc.WithBlock(),
  )
  if err != nil {
      return nil, fmt.Errorf("failed to dial AI server %q: %w", AIAddr, err)
  }
  client := aisvc.NewAIServiceClient(conn)
  return &ExampleAIClient{conn: conn, client: client, ctx: ctx}, nil
}


func (c *ExampleAIClient) Close() error {
  return c.conn.Close()
}


// ---- CreateNonLinearAlgorithmIndex ----
func (c *ExampleAIClient) exampleCreateNonLinearIndexAI() error {
  // Create an HNSW index (with optional config)
  _, err := c.client.CreateNonLinearAlgorithmIndex(c.ctx, &aiquery.CreateNonLinearAlgorithmIndex{
      Store: "ai_store",
      Schema: stringPtr("analytics"), // Optional: defaults to public when omitted
      NonLinearIndices: []*nonlinear.NonLinearIndex{
          {Index: &nonlinear.NonLinearIndex_Hnsw{Hnsw: &nonlinear.HNSWConfig{}}},
      },
  })
  if err != nil {
      return err
  }
  fmt.Println(" Successfully created NonLinearAlgorithm index: HNSW on store ai_store")
  return nil
}


func main() {
  ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
  defer cancel()


  client, err := NewAIClient(ctx)
  if err != nil {
      log.Fatalf(" Failed to create AI client: %v", err)
  }
  defer client.Close()


  if err := client.exampleCreateNonLinearIndexAI(); err != nil {
      log.Fatalf(" CreateNonLinearAlgorithmIndex failed: %v", err)
  }
}

Rust

Rust

use ahnlich_client_rs::ai::AiClient;
use ahnlich_types::ai::query::CreateNonLinearAlgorithmIndex;
use ahnlich_types::algorithm::nonlinear::{NonLinearIndex, non_linear_index, HnswConfig};
use tokio;


#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = AiClient::new("http://127.0.0.1:1370".to_string()).await?;

    // Create an HNSW index (with default config)
    let params = CreateNonLinearAlgorithmIndex {
        store: "MyStore".to_string(),
        schema: Some("analytics".to_string()),
        non_linear_indices: vec![
            NonLinearIndex {
                index: Some(non_linear_index::Index::Hnsw(HnswConfig::default())),
            },
        ],
    };

    let result = client.create_non_linear_algorithm_index(params, None).await?;
    println!("Created non-linear indices: {:?}", result);

    Ok(())
}

CLI

$CREATENONLINEARALGORITHMINDEX (hnsw) IN my_store

Response

The number of indexes created.

Related

• Similarity search
• Drop non-linear index