Enhance documentation and examples for HNSW (JVector) indexing

- Updated references from JVector to HNSW (JVector) across multiple documentation files, including testing guides, examples, and index descriptions.
- Clarified the use of HNSW in vector search examples and improved explanations of indexing performance.
- Adjusted code snippets to reflect best practices for using HNSW (JVector) in various contexts, including schema creation and data import.
- Removed deprecated JSON import examples and streamlined CSV import documentation.
- Ensured consistency in terminology and improved clarity in descriptions of vector search capabilities.

Author: tae898

bindings/python/README.md

@@ -75,7 +75,7 @@ with arcadedb.create_database("/tmp/mydb") as db:
 - 🔍 **Multiple query languages**: SQL, Cypher, Gremlin, MongoDB
 - ⚡ **High performance**: Direct JVM integration via JPype
 - 🔒 **ACID transactions**: Full transaction support
-- 🎯 **Vector storage**: Store and query vector embeddings with JVector indexing
+- 🎯 **Vector storage**: Store and query vector embeddings with HNSW (JVector) indexing
 - 📥 **Data import**: Built-in CSV and ArcadeDB JSONL import
 
 ---
@@ -208,7 +208,7 @@ arcadedb_embedded/
 ├── results.py           # ResultSet and Result wrappers
 ├── transactions.py      # TransactionContext manager
 ├── schema.py            # Schema management API
-├── vector.py            # Vector search and JVector indexing
+├── vector.py            # Vector search and HNSW (JVector) indexing
 ├── importer.py          # Data import (CSV, JSONL)
 ├── exporter.py          # Data export (JSONL, GraphML, GraphSON, CSV)
 ├── batch.py             # Batch operations context

bindings/python/docs/api/async_executor.md

@@ -2,6 +2,18 @@
 
 The AsyncExecutor provides low-level async operations for parallel processing, automatic batching, and optimized WAL operations. It offers 3-5x faster bulk inserts compared to sequential operations.
 
+!!! tip "Using Context Managers"
+    For automatic resource cleanup, prefer using context managers:
+    ```python
+    with arcadedb.create_database("./mydb") as db:
+        async_exec = db.async_executor()
+        async_exec.set_parallel_level(8)
+        # Use for bulk operations...
+        async_exec.wait_completion()
+    # Database automatically closed
+    ```
+    Examples below show explicit `db.close()` for clarity, but context managers are recommended in production.
+
 ## Overview
 
 The `AsyncExecutor` class enables:

bindings/python/docs/api/database.md

@@ -431,18 +431,18 @@ db.create_vector_index(
 ) -> VectorIndex
 ```
 
-Create a vector index for similarity search (default JVector implementation).
+Create a vector index for similarity search (default HNSW (JVector) implementation).
 
 **Note:** The index is built lazily. Construction happens upon the first query, not at creation time.
 
-**Parameters:**
+**Parameters:**`
 
 - `vertex_type` (str): Vertex type containing vectors
 - `vector_property` (str): Property storing vector arrays
 - `dimensions` (int): Vector dimensionality
 - `distance_function` (str): `"cosine"`, `"euclidean"`, or `"inner_product"`
-- `max_connections` (int): Max connections per node (default: 32). Maps to `maxConnections` in JVector.
-- `beam_width` (int): Beam width for search/construction (default: 256). Maps to `beamWidth` in JVector.
+- `max_connections` (int): Max connections per node (default: 32). Maps to `maxConnections` in HNSW (JVector).
+- `beam_width` (int): Beam width for search/construction (default: 256). Maps to `beamWidth` in HNSW (JVector).
 
 **Returns:**
 
@@ -751,6 +751,6 @@ else:
 ## See Also
 
 - [Graph Operations](../guide/graphs.md): Working with vertices and edges
-- [Vector Search](../guide/vectors.md): Similarity search with JVector indexes
+- [Vector Search](../guide/vectors.md): Similarity search with HNSW (JVector) indexes
 - [Server Mode](../guide/server.md): HTTP API and Studio UI
 - [Quick Start](../getting-started/quickstart.md): Getting started guide

bindings/python/docs/api/exporter.md

@@ -2,6 +2,15 @@
 
 The Exporter provides utilities for exporting database content to various formats including JSONL, GraphML, and GraphSON.
 
+!!! tip "Using Context Managers"
+    For automatic resource cleanup, prefer using context managers:
+    ```python
+    with arcadedb.open_database("./mydb") as db:
+        export_database(db, "./export.jsonl", format="jsonl")
+    # Database automatically closed
+    ```
+    Examples below show explicit `db.close()` for clarity, but context managers are recommended in production.
+
 ## Overview
 
 The `exporter` module enables:

bindings/python/docs/api/importer.md

@@ -1,19 +1,24 @@
 # Importer API
 
-The `Importer` class and convenience functions provide high-performance data import capabilities for ArcadeDB. The Java importer supports CSV/TSV and XML. For full-database migrations, use ArcadeDB's native JSONL export/import via the `IMPORT DATABASE file://...` SQL command (see JSONL example below).
+The `Importer` class and convenience functions provide high-performance data import
+capabilities for ArcadeDB. For full-database migrations, use ArcadeDB's native JSONL
+export/import via the `IMPORT DATABASE file://...` SQL command (see JSONL example
+below).
 
 ## Overview
 
 The importer uses streaming parsers for memory efficiency and performs batch transactions (default 1000 records per commit) for optimal performance. It can import data as documents, vertices, or edges depending on your schema needs.
 
 **Supported Formats:**
-- **CSV/TSV**: Comma or tab-separated values
-- **XML**: Attribute-focused importer
+- **CSV/TSV**: Comma or tab-separated values (recommended for bulk imports)
 - **ArcadeDB JSONL export/import**: Use `IMPORT DATABASE file://...` via SQL for full database moves (see example)
+- **XML**: Limited support via Java importer (not recommended for production use)
 
 ## Module Functions
 
-Convenience functions for common import tasks without creating an `Importer` instance. These call the underlying Java importer (CSV/TSV, XML) or native SQL for full-database JSONL imports.
+Convenience functions for common import tasks without creating an `Importer` instance.
+These call the underlying Java importer (CSV/TSV) or native SQL for full-database JSONL
+imports.
 
 ### `import_csv(database, file_path, type_name, **options)`
 
@@ -26,11 +31,13 @@ Import CSV or TSV files as documents, vertices, or edges.
 - `**options`: Format-specific options
     - `delimiter` (str): Field delimiter (default: ',', use '\t' for TSV)
     - `header` (bool): File has header row (default: True)
-    - `commit_every` (int): Records per transaction (default: 1000)
-    - `vertex_type` (str): Import as vertices (optional)
-    - `edge_type` (str): Import as edges (optional)
+    - `commitEvery` or `commit_every` (int): Records per transaction (default: 1000)
+    - `import_type` (str): `"documents"` (default), `"vertices"`, or `"edges"`
+    - `typeIdProperty` (str): ID column when importing vertices (e.g., "id")
+    - `vertexType` (str): Optional explicit vertex type name (defaults to `type_name`)
     - `from_property` (str): Source column for edges (default: 'from')
     - `to_property` (str): Target column for edges (default: 'to')
+    - `edgeType` (str): Optional explicit edge type name (defaults to `type_name`)
     - `verbose` (bool): Print errors during import (default: False)
 
 **Examples:**
@@ -43,41 +50,29 @@ stats = arcadedb.import_csv(db, "people.csv", "Person")
 **Import as Vertices:**
 ```python
 stats = arcadedb.import_csv(
-        db, "users.csv", "User",
-        vertex_type="User",
-        commit_every=500
+    db, "users.csv", "User",
+    import_type="vertices",
+    typeIdProperty="id",
+    commitEvery=500
 )
 ```
 
 **Import as Edges:**
 ```python
 stats = arcadedb.import_csv(
-        db, "follows.csv", "Follows",
-        edge_type="Follows",
-        from_property="user_rid",
-        to_property="follows_rid",
-        header=True
+    db, "follows.csv", "Follows",
+    import_type="edges",
+    from_property="from_rid",
+    to_property="to_rid"
 )
 ```
 
-**Import TSV:**
-```python
-stats = arcadedb.import_csv(
-        db, "data.tsv", "Data",
-        delimiter='\t'
-)
-```
-
-### ArcadeDB JSONL import (native SQL)
-
-Use SQL `IMPORT DATABASE file://...` for JSONL exports produced by ArcadeDB. This preserves schema and data and is recommended for full migrations.
-
+**Full-Database Import (JSONL):**
 ```python
 import arcadedb_embedded as arcadedb
 
-db = arcadedb.create_database("./restored_db")
-db.command("sql", "IMPORT DATABASE file:///tmp/export.jsonl.tgz WITH commitEvery = 50000")
-db.close()
+with arcadedb.create_database("./restored_db") as db:
+    db.command("sql", "IMPORT DATABASE file:///tmp/export.jsonl.tgz WITH commitEvery = 50000")
 ```
 
 For XML imports, use the `Importer` class directly (see below) with `format_type='xml'`.
@@ -130,7 +125,6 @@ Import data from a file with auto-detection or explicit format specification.
 importer = Importer(db)
 
 # Auto-detect format from extension
-stats = importer.import_file("data.json")
 stats = importer.import_file("users.csv", type_name="User")
 
 # Explicit format
@@ -146,31 +140,6 @@ stats = importer.import_file(
 
 ## Format-Specific Details
 
-### JSON Format
-
-**File Structure:**
-- Single JSON object: `{...}`
-- Array of objects: `[{...}, {...}]`
-- Multiple root objects: `{...}\n{...}`
-
-**Options:**
-- `mapping` (Dict): Map JSON paths to database types (advanced)
-
-**Type Inference:** The importer uses Java's `JSONImporterFormat` which automatically creates schema based on JSON structure.
-
-**Example:**
-```python
-# data.json:
-# [
-#   {"name": "Alice", "age": 30, "city": "NYC"},
-#   {"name": "Bob", "age": 25, "city": "LA"}
-# ]
-
-stats = arcadedb.import_json(db, "data.json", commit_every=1000)
-```
-
----
-
 ### CSV Format
 
 **File Structure:**
@@ -342,35 +311,27 @@ except arcadedb.ArcadeDBError as e:
 ```python
 import arcadedb_embedded as arcadedb
 
-# Open or create database
-db = arcadedb.create_database("./import_demo")
-
-# Create schema
-db.command("sql", "CREATE DOCUMENT TYPE User")
-db.command("sql", "CREATE VERTEX TYPE Person")
-db.command("sql", "CREATE EDGE TYPE Knows")
-
-# Import documents from JSON
-stats1 = arcadedb.import_json(db, "users.json")
-print(f"Users: {stats1['documents']}")
-
-# Import vertices from CSV
-stats2 = arcadedb.import_csv(
-    db, "people.csv", "Person",
-    vertex_type="Person"
-)
-print(f"People: {stats2['vertices']}")
-
-# Import edges from CSV
-stats3 = arcadedb.import_csv(
-    db, "relationships.csv", "Knows",
-    edge_type="Knows",
-    from_property="person1_rid",
-    to_property="person2_rid"
-)
-print(f"Relationships: {stats3['edges']}")
-
-db.close()
+# Open or create database (auto-closes)
+with arcadedb.create_database("./import_demo") as db:
+    # Create schema with embedded API
+    db.schema.create_vertex_type("Person")
+    db.schema.create_edge_type("Knows")
+
+    # Import vertices from CSV
+    stats = arcadedb.import_csv(
+        db, "people.csv", "Person",
+        vertex_type="Person"
+    )
+    print(f"People: {stats['vertices']}")
+
+    # Import edges from CSV
+    stats2 = arcadedb.import_csv(
+        db, "relationships.csv", "Knows",
+        edge_type="Knows",
+        from_property="person1_rid",
+        to_property="person2_rid"
+    )
+    print(f"Relationships: {stats2['edges']}")
 ```
 
 ### Large-Scale Import with Progress Tracking
@@ -379,36 +340,30 @@ db.close()
 import arcadedb_embedded as arcadedb
 import time
 
-db = arcadedb.create_database("./large_import")
-
-# Create schema
-db.command("sql", "CREATE VERTEX TYPE Product")
+with arcadedb.create_database("./large_import") as db:
+    # Create schema with embedded API
+    db.schema.create_vertex_type("Product")
 
-# Import with progress monitoring
-print("Starting import...")
-start = time.time()
+    # Import with progress monitoring
+    print("Starting import...")
+    start = time.time()
 
-stats = arcadedb.import_csv(
-    db, "products.csv", "Product",
-    vertex_type="Product",
-    commit_every=10000,  # Large batches for performance
-    verbose=True  # Show errors
-)
+    stats = arcadedb.import_csv(
+        db, "products.csv", "Product",
+        vertex_type="Product",
+        commit_every=10000,  # Large batches for performance
+        verbose=True  # Show errors
+    )
 
-elapsed = time.time() - start
+    elapsed = time.time() - start
 
-print(f"\nImport complete!")
-print(f"Records: {stats['vertices']:,}")
-print(f"Errors: {stats['errors']}")
-print(f"Time: {elapsed:.2f}s")
-print(f"Rate: {stats['vertices'] / elapsed:.0f} records/sec")
-
-# Create indexes after import
-print("\nCreating indexes...")
-db.command("sql", "CREATE INDEX ON Product (sku) UNIQUE")
-db.command("sql", "CREATE INDEX ON Product (category) NOTUNIQUE")
+    print(f"\nImport complete!")
+    print(f"Records: {stats['vertices']:,}")
+    print(f"Errors: {stats['errors']}")
+    print(f"Time: {elapsed:.2f}s")
+    print(f"Rate: {stats['vertices'] / elapsed:.0f} records/sec")
 
-db.close()
+    # Create indexes after import
 ```
 
 ### ArcadeDB JSONL Import (native export)
@@ -418,14 +373,14 @@ Use ArcadeDB's built-in SQL command to import JSONL exports created by `EXPORT D
 ```python
 import arcadedb_embedded as arcadedb
 
-db = arcadedb.create_database("./restored_db")
 import_path = "/exports/mydb.jsonl.tgz"  # JSONL export created by ArcadeDB
 
-# Use SQL IMPORT DATABASE with optional tuning parameters
-db.command("sql", f"IMPORT DATABASE file://{import_path} WITH commitEvery = 50000")
+# Use context manager for lifecycle
+with arcadedb.create_database("./restored_db") as db:
+    # Use SQL IMPORT DATABASE with optional tuning parameters
+    db.command("sql", f"IMPORT DATABASE file://{import_path} WITH commitEvery = 50000")
 
-print("Import complete!")
-db.close()
+    print("Import complete!")
 ```
 
 This approach preserves the full database (schema + data) and is the recommended path for large migrations or round-tripping ArcadeDB exports.

bindings/python/docs/api/results.md

@@ -2,6 +2,17 @@
 
 The `ResultSet` and `Result` classes provide Python-friendly interfaces for working with query results from ArcadeDB. They handle iteration, property access, and type conversion automatically.
 
+!!! tip "Using Context Managers"
+    For automatic resource cleanup, prefer using context managers:
+    ```python
+    with arcadedb.open_database("./mydb") as db:
+        result_set = db.query("sql", "SELECT FROM Person WHERE age > 25")
+        for result in result_set:
+            print(result.get("name"))
+    # Database automatically closed
+    ```
+    Examples below show explicit `db.close()` for clarity, but context managers are recommended in production.
+
 ## Overview
 
 When you execute a query, ArcadeDB returns a `ResultSet` that can be iterated to access individual `Result` objects. Each `Result` represents one row/record from your query.