shadylukin/neumann/neumann-client

// Rust -- remote (async)
let client = NeumannClient::connect("localhost:9200")
    .api_key("key").with_tls().timeout_ms(30_000).build().await?;
 
// Rust -- embedded (sync, no server needed; feature = "embedded")
let client = NeumannClient::embedded()?;
let result = client.execute_sync("SELECT users")?;

# Python -- sync
with NeumannClient.connect("localhost:9200", api_key="...") as client:
    result = client.query("SELECT users")
# Python -- async
async with AsyncNeumannClient("localhost:9200") as client:
    result = await client.query("SELECT users")

// TypeScript -- Node.js (gRPC) or browser (gRPC-Web via connectWeb)
const client = await NeumannClient.connect('localhost:9200', { apiKey: 'key' });
const result = await client.query('SELECT users');
client.close();

use query_router::QueryResult;
 
match result {
    QueryResult::Rows(rows) => { /* Vec<Row> */ }
    QueryResult::Nodes(nodes) => { /* Vec<NodeResult> */ }
    QueryResult::Edges(edges) => { /* Vec<EdgeResult> */ }
    QueryResult::Similar(items) => { /* Vec<SimilarResult> */ }
    QueryResult::Count(n) => { /* usize */ }
    QueryResult::Value(s) => { /* String */ }
    QueryResult::Path(ids) => { /* Vec<u64> */ }
    QueryResult::TableList(names) => { /* Vec<String> */ }
    QueryResult::Empty => { /* DDL/DML success */ }
    _ => { /* handle other variants */ }
}

from neumann.types import QueryResultType
if result.type == QueryResultType.ROWS:
    for row in result.rows:
        print(row.get_string("name"), row.get_int("age"))
        print(row.to_dict())  # {"name": "Alice", "age": 30}
elif result.type == QueryResultType.NODES:
    for node in result.nodes:
        print(node.label, node.properties)
elif result.type == QueryResultType.SIMILAR:
    for item in result.similar_items:
        print(item.key, item.score)
elif result.type == QueryResultType.COUNT:
    print(result.count)

import { isRowsResult, isNodesResult, isSimilarResult, rowToObject } from '@neumann/client';
if (isRowsResult(result)) {
  for (const row of result.rows) {
    console.log(rowToObject(row));
  }
} else if (isNodesResult(result)) {
  for (const node of result.nodes) {
    console.log(node.label, node.properties);
  }
} else if (isSimilarResult(result)) {
  for (const item of result.items) {
    console.log(item.key, item.score);
  }
}

from neumann import VectorClient
vc = VectorClient.connect("localhost:9200")
vc.create_collection("docs", dimension=384, distance="cosine")
vc.upsert_points("docs", [VectorPoint(id="d1", vector=[...], payload={"title": "Hello"})])
results = vc.query_points("docs", query_vector=[...], limit=10)

const vc = await VectorClient.connect('localhost:9200');
await vc.createCollection('docs', 384, 'cosine');
await vc.upsertPoints('docs', [{ id: 'd1', vector: [...], payload: { title: 'Hello' } }]);
const results = await vc.queryPoints('docs', queryVector, { limit: 10 });

config = ClientConfig.high_latency()
client = NeumannClient.connect("remote-host:9200", config=config)

import { highLatencyConfig } from '@neumann/client';
const client = await NeumannClient.connect('remote-host:9200', highLatencyConfig());