Weaviate Python Client

The weaviate.collections.classes module serves as the primary namespace for managing collection-level configurations, operations, and metadata in the Weaviate Python Client. It is organized into several specialized sub-modules that handle different aspects of a collection's lifecycle and functionality:

• aggregate: Methods for performing aggregation queries on a collection.
• batch: Tools for performing batch operations (insertions, updates, deletions) on a collection.
• cluster: Operations related to cluster-level management for the collection.
• config: Configuration management, including vector index settings, vectorizers, and named vectors.
• data: Operations related to the underlying data within the collection.
• filters: Logic and types for constructing complex metadata filters.
• grpc: Configuration and settings specific to gRPC communication for the collection.
• orm: Object-Relational Mapping capabilities for interacting with collection objects.
• tenants: Management of multi-tenancy features, such as creating and deleting tenants.
• types: Type definitions and schemas used throughout the collection modules.

The weaviate.collections module is the primary entry point for interacting with collections (classes) in Weaviate. It provides a structured hierarchy of subpackages to manage different aspects of collection operations, including data manipulation, querying, configuration, and administrative tasks.

Key functional areas available through subpackages include:

• Data & Operations: batch for high-performance ingestion, data for CRUD, iterator for large-scale data traversal, and orm for object-relational mapping.
• Querying & Filtering: query for retrieving objects, filters for constructing complex search criteria, aggregations for statistical analysis, and generate for generative AI features.
• Management & Configuration: classes for schema definition, config for inspecting collection settings, tenants for multi-tenancy, backups for data persistence, and cluster for cluster-level operations.
• Infrastructure: grpc for low-level communication.

The weaviate.outputs module contains the data models and response structures returned by various Weaviate API operations. Instead of working with raw JSON, the client uses these structured objects to provide type safety and easier access to data. The outputs are organized into sub-modules corresponding to the functional areas of the API:

• weaviate.outputs.aggregate: Structures for aggregation results.
• weaviate.outputs.backup: Structures for backup operations and statuses.
• weaviate.outputs.batch: Structures for batch processing results.
• weaviate.outputs.cluster: Structures related to cluster health and status.
• weaviate.outputs.config: Structures for schema and configuration data.
• weaviate.outputs.data: Structures for core data objects (e.g., objects, properties).
• weaviate.outputs.query: Structures for search and retrieval results.
• weaviate.outputs.rbac: Structures for Role-Based Access Control.
• weaviate.outputs.tenants: Structures for multi-tenancy and tenant management.

The weaviate.collections.queries module provides access to various query methods for retrieving data from a collection. Depending on your search requirements (keyword, vector, hybrid, or media-based), you will use one of the following specialized submodules:

• Keyword/BM25: weaviate.collections.queries.bm25
• ID-based retrieval: weaviate.collections.queries.fetch_object_by_id and weaviate.collections.queries.fetch_objects_by_ids
• General object retrieval: weaviate.collections.queries.fetch_objects
• Hybrid search: weaviate.collections.queries.hybrid
• Vector/Near-based search:
  • weaviate.collections.queries.near_vector (search by raw vector)
  • weaviate.collections.queries.near_text (search by text embedding)
  • weaviate.collections.queries.near_object (search by an existing object)
• Media/Image search:
  • weaviate.collections.queries.near_image
  • weaviate.collections.queries.near_media

The weaviate package is organized into several specialized subpackages that handle different aspects of interacting with a Weaviate instance. Depending on your task, you will use different modules:

• weaviate.backup: Manage backups and restores.
• weaviate.classes: High-level object-oriented interfaces for collections and properties.
• weaviate.cluster: Manage cluster-level operations.
• weaviate.collections: Interface for interacting with collections (data schemas and objects).
• weaviate.connect: Connection management and client instantiation.
• weaviate.debug: Tools for debugging and inspecting Weaviate state.
• weaviate.gql: Execute raw GraphQL queries.
• weaviate.outputs: Standardized output formats for client responses.
• weaviate.rbac: Role-Based Access Control management.
• weaviate.users: User management operations.
• weaviate.auth: Authentication mechanisms and credentials.
• weaviate.config: Configuration settings for the client and connection.
• weaviate.embedded: Utilities for running Weaviate in embedded mode.

The weaviate.classes module serves as the primary namespace for high-level, type-safe classes used to interact with Weaviate. Instead of using raw dictionaries or strings for complex operations, you use these specialized classes to construct queries, manage configurations, and handle data.

Key sub-modules include:

• weaviate.classes.query: For constructing advanced search and retrieval queries.
• weaviate.classes.data: For managing object data and properties.
• weaviate.classes.config: For defining and modifying collection schemas and configurations.
• weaviate.classes.batch: For performing high-performance bulk data operations.
• weaviate.classes.aggregate: For performing statistical aggregations over collections.
• weaviate.classes.backup: For managing database backups.
• weaviate.classes.tenants: For managing multi-tenancy features.
• weaviate.classes.rbac: For Role-Based Access Control configurations.
• weaviate.classes.init: For initialization-related logic.
• weaviate.classes.debug: For debugging and diagnostic purposes.
• weaviate.classes.generics: For generic type definitions used within the client.

The weaviate-agents-python-client documentation is integrated into the main Weaviate Python Client documentation site. This is achieved by cloning the agents repository during the RTD pre_build phase and adding it to the Sphinx path.

Integration Mechanism:

• .readthedocs.yaml: Uses a pre_build hook to git clone the main branch of the agents repo into docs/weaviate-agents-python-client and installs it in editable mode.
• docs/conf.py: Inserts the cloned directory into sys.path so Sphinx can resolve the modules.

Key Behaviors:

• The agents docs are pulled from the main branch of the agents repository.
• Changes in the agents repository are not automatically reflected in the published docs immediately; they update when a new release of weaviate-python-client is cut or when a manual rebuild is triggered in RTD.
• Sphinx picks up the agents' documentation because its .rst files reside within the cloned directory structure under the main source tree.

# .readthedocs.yaml snippet
build:
  jobs:
    pre_build:
      - git clone -b main --depth=1 https://github.com/weaviate/weaviate-agents-python-client.git docs/weaviate-agents-python-client
      - python -m pip install -e ./docs/weaviate-agents-python-client

# docs/conf.py snippet
sys.path.insert(0, os.path.abspath("weaviate-agents-python-client"))