Delete by key

Delete entries by an exact vector-key match.

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	Name of the store to delete from.
keys	list of vectors	The exact vector keys to remove.
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

• Removes only the entries whose key matches exactly.
• Keys that aren't present are silently ignored.

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 import keyval


async def delete_key():
  async with Channel(host="127.0.0.1", port=1369) as channel:
      client = DbServiceStub(channel)
      
      store_key = keyval.StoreKey(key=[1.0, 2.0, 3.0, 4.0])
      
      response = await client.del_key(
          db_query.DelKey(
              store="my_store",
              schema="analytics",
              keys=[store_key]
          )
      )
      # response.deleted_count shows how many items were deleted
  print(response)
        


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

Node.js

TypeScript

import { createDbClient } from "ahnlich-client-node";
import { DelKey } from "ahnlich-client-node/grpc/db/query_pb";
import { StoreKey } from "ahnlich-client-node/grpc/keyval_pb";

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

  await client.delKey(
    new DelKey({
      store: "my_store",
      schema: "analytics",
      keys: [new StoreKey({ key: [1.0, 2.0, 3.0, 4.0] })],
    })
  );

  console.log("Entry deleted successfully");
}

deleteKey();

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"
    keyval  "github.com/deven96/ahnlich/sdk/ahnlich-client-go/grpc/keyval"
)


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()
}


// -------------------- Delete Key --------------------
func (c *ExampleDBClient) exampleDeleteKey() error {
    _, err := c.client.DelKey(c.ctx, &dbquery.DelKey{
        Store: "my_store",
        Schema: stringPtr("analytics"), // Optional: defaults to public when omitted
        Keys:  []*keyval.StoreKey{{Key: []float32{1, 2, 3, 4}}},
    })
    if err != nil {
        return err
    }
    fmt.Println("Deleted key from store: my_store")
    return nil
}


// -------------------- Main --------------------
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.exampleDeleteKey(); err != nil {
        log.Fatalf("DeleteKey failed: %v", err)
    }
}

Rust

Rust

use ahnlich_client_rs::db::DbClient;
use ahnlich_types::db::query::DelKey;
use ahnlich_types::keyval::StoreKey;
use tokio;


#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "http://127.0.0.1:1369"; // adjust if your server runs elsewhere
    let client = DbClient::new(addr.to_string()).await?;


    // Delete a specific key from store "my_store" (dimension must match)
    let del_key_params = DelKey {
        store: "my_store".to_string(),
        schema: Some("analytics".to_string()),
        keys: vec![StoreKey {
            key: vec![1.0, 1.1, 1.2], // ✅ matches dimension=4
        }],
    };


    match client.del_key(del_key_params, None).await {
        Ok(result) => println!("Deleted count: {:?}", result.deleted_count),
        Err(e) => eprintln!("Error: {:?}", e),
    }


    Ok(())
}

CLI

$DELETEKEY (key1) 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 import keyval


async def drop_key():
  async with Channel(host="127.0.0.1", port=1370) as channel:
      client = AiServiceStub(channel)
      response = await client.del_key(
          ai_query.DelKey(
              store="my_store",
              schema="analytics",
              keys=[keyval.StoreInput(raw_string="Custom Made Jordan 4")]
          )
      )
      print(response) # Del()


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

Node.js

TypeScript

import { createAiClient } from "ahnlich-client-node";
import { DelKey } from "ahnlich-client-node/grpc/ai/query_pb";
import { StoreInput } from "ahnlich-client-node/grpc/keyval_pb";

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

  await client.delKey(
    new DelKey({
      store: "ai_store",
      schema: "analytics",
      keys: [
        new StoreInput({ value: { case: "rawString", value: "Jordan One" } }),
      ],
    })
  );

  console.log("Entry deleted");
}

deleteKey();

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"
  keyval "github.com/deven96/ahnlich/sdk/ahnlich-client-go/grpc/keyval"
)


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 creates and connects the AI client
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()
}


// ---- DelKey  ----
func (c *ExampleAIClient) exampleDeleteKeyAI() error {
  _, err := c.client.DelKey(c.ctx, &aiquery.DelKey{
      Store: "ai_store01",
      Schema: stringPtr("analytics"), // Optional: defaults to public when omitted
      Keys: []*keyval.StoreInput{
          {Value: &keyval.StoreInput_RawString{RawString: "X"}},
      },
  })
  if err != nil {
      return err
  }
  fmt.Println(" Successfully deleted key 'X' from 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.exampleDeleteKeyAI(); err != nil {
      log.Fatalf(" DeleteKey failed: %v", err)
  }
}

Rust

Rust

use ahnlich_client_rs::ai::AiClient;
use ahnlich_client_rs::error::AhnlichError;
use ahnlich_types::ai::query::DelKey;
use ahnlich_types::ai::server::Del;
use ahnlich_types::keyval::StoreInput;
use ahnlich_types::keyval::store_input::Value;


#[tokio::main]
async fn main() -> Result<(), AhnlichError> {
    // Connect to server
    let ai_client = AiClient::new("http://127.0.0.1:1370".to_string())
        .await
        .expect(" Failed to connect AI client");


    // Define key to delete
    let params = DelKey {
        store: "Deven Kicks".to_string(),
        schema: Some("analytics".to_string()),
        keys: vec![StoreInput {
            value: Some(Value::RawString("Nike Air Jordans".to_string())),
        }],
    };


    // Call delete
    let response: Del = ai_client.del_key(params, None).await?;
    println!(" Deleted key result: {:?}", response);


    Ok(())
}

CLI

$DELETEKEY ([This is a sentence]) IN my_store

Response

The number of entries deleted.

Related

• Delete by predicate
• Get by key