diff --git a/airbyte_cdk/cli/airbyte_cdk/_connector.py b/airbyte_cdk/cli/airbyte_cdk/_connector.py
index d09ed4540..5c62dc44a 100644
--- a/airbyte_cdk/cli/airbyte_cdk/_connector.py
+++ b/airbyte_cdk/cli/airbyte_cdk/_connector.py
@@ -174,6 +174,10 @@ def test(
     )
 
 
+from airbyte_cdk.cli.airbyte_cdk._qa import pre_release_check
+
+connector_cli_group.add_command(pre_release_check)
+
 __all__ = [
     "connector_cli_group",
 ]
diff --git a/airbyte_cdk/cli/airbyte_cdk/_qa.py b/airbyte_cdk/cli/airbyte_cdk/_qa.py
new file mode 100644
index 000000000..166dea2f3
--- /dev/null
+++ b/airbyte_cdk/cli/airbyte_cdk/_qa.py
@@ -0,0 +1,94 @@
+"""CLI command for running QA checks on connectors using pytest."""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+import rich_click as click
+
+from airbyte_cdk.cli.airbyte_cdk._util import resolve_connector_name_and_directory
+
+
+@click.command(name="pre-release-check")
+@click.option(
+    "-c",
+    "--check",
+    "selected_checks",
+    multiple=True,
+    help="The name of the check to run. If not provided, all checks will be run.",
+)
+@click.option(
+    "--connector-name",
+    type=str,
+    help="Name of the connector to check. Ignored if --connector-directory is provided.",
+)
+@click.option(
+    "--connector-directory",
+    type=click.Path(exists=True, file_okay=False, path_type=Path),
+    help="Path to the connector directory.",
+)
+@click.option(
+    "-r",
+    "--report-path",
+    "report_path",
+    type=click.Path(file_okay=True, path_type=Path, writable=True, dir_okay=False),
+    help="The path to the report file to write the results to as JSON.",
+)
+def pre_release_check(
+    selected_checks: List[str],
+    connector_name: Optional[str] = None,
+    connector_directory: Optional[Path] = None,
+    report_path: Optional[Path] = None,
+) -> None:
+    """Run pre-release checks on a connector using pytest.
+
+    This command runs quality assurance checks on a connector to ensure it meets
+    Airbyte's standards for release. The checks include:
+
+    - Documentation checks
+    - Metadata checks
+    - Packaging checks
+    - Security checks
+    - Asset checks
+    - Testing checks
+
+    If no connector name or directory is provided, we will look within the current working
+    directory. If the current working directory is not a connector directory (e.g. starting
+    with 'source-') and no connector name or path is provided, the process will fail.
+    """
+    connector_name, connector_directory = resolve_connector_name_and_directory(
+        connector_name=connector_name,
+        connector_directory=connector_directory,
+    )
+
+    pytest_args = ["-xvs"]
+    
+    if connector_name:
+        pytest_args.extend(["--connector-name", connector_name])
+    if connector_directory:
+        pytest_args.extend(["--connector-directory", str(connector_directory)])
+    
+    if report_path:
+        pytest_args.extend(["--report-path", str(report_path)])
+    
+    if selected_checks:
+        for check in selected_checks:
+            pytest_args.extend(["-k", check])
+    
+    qa_module_path = Path(__file__).parent.parent.parent / "qa"
+    pytest_args.extend(["-p", "airbyte_cdk.qa.pytest_plugin"])
+    
+    test_paths = []
+    for root, _, files in os.walk(qa_module_path / "checks"):
+        for file in files:
+            if file.endswith("_test.py"):
+                test_paths.append(os.path.join(root, file))
+    
+    cmd = [sys.executable, "-m", "pytest"] + pytest_args + test_paths
+    click.echo(f"Running: {' '.join(cmd)}")
+    result = subprocess.run(cmd)
+    
+    if result.returncode != 0:
+        raise click.ClickException(f"Pytest failed with exit code {result.returncode}")
diff --git a/airbyte_cdk/qa/__init__.py b/airbyte_cdk/qa/__init__.py
new file mode 100644
index 000000000..1e2ec0f6d
--- /dev/null
+++ b/airbyte_cdk/qa/__init__.py
@@ -0,0 +1,69 @@
+"""The `airbyte_cdk.qa` module provides quality assurance checks for Airbyte connectors.
+
+This module includes a framework for running pre-release checks on connectors to ensure
+they meet Airbyte's quality standards. The checks are organized into categories and can
+be run individually or as a group.
+
+
+The QA module includes the following check categories:
+
+- **Packaging**: Checks related to connector packaging, including dependency management,
+  versioning, and licensing.
+- **Metadata**: Checks related to connector metadata, including language tags, CDK tags,
+  and breaking changes deadlines.
+- **Security**: Checks related to connector security, including HTTPS usage and base image
+  requirements.
+- **Assets**: Checks related to connector assets, including icons and other visual elements.
+- **Documentation**: Checks related to connector documentation, ensuring it exists and is
+  properly formatted.
+- **Testing**: Checks related to connector testing, ensuring acceptance tests are present.
+
+
+Checks can be configured based on various connector attributes:
+
+- **Connector Language**: Checks can be configured to run only on connectors of specific
+  languages (Python, Java, Low-Code, Manifest-Only).
+- **Connector Type**: Checks can be configured to run only on specific connector types
+  (source, destination).
+- **Support Level**: Checks can be configured to run only on connectors with specific
+  support levels (certified, community, etc.).
+- **Cloud Usage**: Checks can be configured to run only on connectors with specific
+  cloud usage settings (enabled, disabled, etc.).
+- **Internal SL**: Checks can be configured to run only on connectors with specific
+  internal service level requirements.
+
+
+Checks can be run using the `airbyte-cdk connector pre-release-check` command:
+
+```bash
+airbyte-cdk connector pre-release-check --connector-name source-example
+
+airbyte-cdk connector pre-release-check --connector-name source-example --check CheckConnectorUsesPoetry --check CheckVersionBump
+
+airbyte-cdk connector pre-release-check --connector-directory /path/to/connector
+
+airbyte-cdk connector pre-release-check --connector-name source-example --report-path report.json
+```
+
+
+The QA module is designed to be extensible. New checks can be added by creating a new
+class that inherits from the `Check` base class and implementing the required methods.
+
+Example:
+
+```python
+from airbyte_cdk.qa.models import Check, CheckCategory, CheckResult
+from airbyte_cdk.qa.connector import Connector
+
+class MyCustomCheck(Check):
+    name = "My custom check"
+    description = "Description of what my check verifies"
+    category = CheckCategory.TESTING
+
+    def _run(self, connector: Connector) -> CheckResult:
+        if some_condition:
+            return self.pass_(connector, "Check passed message")
+        else:
+            return self.fail(connector, "Check failed message")
+```
+"""
diff --git a/airbyte_cdk/qa/checks/__init__.py b/airbyte_cdk/qa/checks/__init__.py
new file mode 100644
index 000000000..0f2b7349f
--- /dev/null
+++ b/airbyte_cdk/qa/checks/__init__.py
@@ -0,0 +1,17 @@
+"""QA checks for Airbyte connectors."""
+
+from airbyte_cdk.qa.checks.assets import ENABLED_CHECKS as ASSETS_CHECKS
+from airbyte_cdk.qa.checks.documentation import ENABLED_CHECKS as DOCUMENTATION_CHECKS
+from airbyte_cdk.qa.checks.metadata import ENABLED_CHECKS as METADATA_CORRECTNESS_CHECKS
+from airbyte_cdk.qa.checks.packaging import ENABLED_CHECKS as PACKAGING_CHECKS
+from airbyte_cdk.qa.checks.security import ENABLED_CHECKS as SECURITY_CHECKS
+from airbyte_cdk.qa.checks.testing import ENABLED_CHECKS as TESTING_CHECKS
+
+ENABLED_CHECKS = (
+    DOCUMENTATION_CHECKS
+    + METADATA_CORRECTNESS_CHECKS
+    + PACKAGING_CHECKS
+    + ASSETS_CHECKS
+    + SECURITY_CHECKS
+    + TESTING_CHECKS
+)
diff --git a/airbyte_cdk/qa/checks/assets.py b/airbyte_cdk/qa/checks/assets.py
new file mode 100644
index 000000000..414c3848f
--- /dev/null
+++ b/airbyte_cdk/qa/checks/assets.py
@@ -0,0 +1,45 @@
+"""Asset checks for Airbyte connectors."""
+
+from airbyte_cdk.qa import consts
+from airbyte_cdk.qa.connector import Connector
+from airbyte_cdk.qa.models import Check, CheckCategory, CheckResult
+
+
+class AssetCheck(Check):
+    """Base class for asset checks."""
+
+    category = CheckCategory.ASSETS
+
+
+class CheckConnectorHasIcon(AssetCheck):
+    """Check that connectors have an icon."""
+
+    name = "Connectors must have an icon"
+    description = f"Connectors must have an icon file named `{consts.ICON_FILE_NAME}` in their code directory. This is to ensure that all connectors have a visual representation in the UI."
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        icon_path = connector.code_directory / consts.ICON_FILE_NAME
+        if not icon_path.exists():
+            return self.create_check_result(
+                connector=connector,
+                passed=False,
+                message=f"Icon file {consts.ICON_FILE_NAME} does not exist",
+            )
+        return self.create_check_result(
+            connector=connector,
+            passed=True,
+            message=f"Icon file {consts.ICON_FILE_NAME} exists",
+        )
+
+
+ENABLED_CHECKS = [
+    CheckConnectorHasIcon(),
+]
diff --git a/airbyte_cdk/qa/checks/documentation/__init__.py b/airbyte_cdk/qa/checks/documentation/__init__.py
new file mode 100644
index 000000000..ef50b0dcf
--- /dev/null
+++ b/airbyte_cdk/qa/checks/documentation/__init__.py
@@ -0,0 +1,9 @@
+"""Documentation checks for Airbyte connectors."""
+
+from airbyte_cdk.qa.checks.documentation.documentation import (
+    CheckDocumentationExists,
+)
+
+ENABLED_CHECKS = [
+    CheckDocumentationExists(),
+]
diff --git a/airbyte_cdk/qa/checks/documentation/documentation.py b/airbyte_cdk/qa/checks/documentation/documentation.py
new file mode 100644
index 000000000..70ee0a5d4
--- /dev/null
+++ b/airbyte_cdk/qa/checks/documentation/documentation.py
@@ -0,0 +1,54 @@
+"""Documentation checks for Airbyte connectors."""
+
+from pathlib import Path
+
+from airbyte_cdk.qa.connector import Connector
+from airbyte_cdk.qa.models import Check, CheckCategory, CheckResult
+
+
+class DocumentationCheck(Check):
+    """Base class for documentation checks."""
+
+    category = CheckCategory.DOCUMENTATION
+
+
+class CheckDocumentationExists(DocumentationCheck):
+    """Check that connectors have documentation."""
+
+    name = "Connectors must have documentation"
+    description = (
+        "Connectors must have documentation to ensure that users can understand how to use them."
+    )
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        docs_dir = Path("/home/ubuntu/repos/airbyte/docs/integrations")
+        connector_type_dir = docs_dir / (connector.connector_type + "s")
+
+        doc_file = connector_type_dir / (
+            connector.technical_name.replace("source-", "").replace("destination-", "") + ".md"
+        )
+
+        if not doc_file.exists():
+            return self.create_check_result(
+                connector=connector,
+                passed=False,
+                message=f"Documentation file {doc_file} does not exist",
+            )
+        return self.create_check_result(
+            connector=connector,
+            passed=True,
+            message=f"Documentation file {doc_file} exists",
+        )
+
+
+ENABLED_CHECKS = [
+    CheckDocumentationExists(),
+]
diff --git a/airbyte_cdk/qa/checks/metadata.py b/airbyte_cdk/qa/checks/metadata.py
new file mode 100644
index 000000000..a6d4e30bd
--- /dev/null
+++ b/airbyte_cdk/qa/checks/metadata.py
@@ -0,0 +1,316 @@
+"""Metadata checks for Airbyte connectors."""
+
+import os
+from datetime import datetime, timedelta
+
+import toml
+import yaml
+
+from airbyte_cdk.qa import consts
+from airbyte_cdk.qa.connector import Connector, ConnectorLanguage
+from airbyte_cdk.qa.models import Check, CheckCategory, CheckResult
+
+
+class MetadataCheck(Check):
+    """Base class for metadata checks."""
+
+    category = CheckCategory.METADATA
+
+
+class ValidateMetadata(MetadataCheck):
+    """Check that connectors have a valid metadata.yaml file."""
+
+    name = f"Connectors must have valid {consts.METADATA_FILE_NAME} file"
+    description = f"Connectors must have a `{consts.METADATA_FILE_NAME}` file at the root of their directory. This file is used to build our connector registry. Its structure must follow our metadata schema."
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        if not connector.metadata_file_path.exists():
+            return self.fail(
+                connector=connector,
+                message=f"Metadata file {consts.METADATA_FILE_NAME} does not exist",
+            )
+
+        try:
+            with open(connector.metadata_file_path, "r") as f:
+                yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            return self.fail(
+                connector=connector, message=f"Metadata file is invalid YAML: {str(e)}"
+            )
+
+        return self.pass_(
+            connector=connector,
+            message="Metadata file exists and is valid YAML.",
+        )
+
+
+class CheckConnectorLanguageTag(MetadataCheck):
+    """Check that connectors have a language tag in metadata."""
+
+    name = "Connector must have a language tag in metadata"
+    description = f"Connectors must have a language tag in their metadata. It must be set in the `tags` field in {consts.METADATA_FILE_NAME}. The values can be `language:python` or `language:java`."
+
+    PYTHON_LANGUAGE_TAG = "language:python"
+    JAVA_LANGUAGE_TAG = "language:java"
+    MANIFEST_ONLY_LANGUAGE_TAG = "language:manifest-only"
+
+    def get_expected_language_tag(self, connector: Connector) -> str:
+        """Get the expected language tag for the connector.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            str: The expected language tag
+
+        Raises:
+            ValueError: If the language tag cannot be inferred
+        """
+        if (connector.code_directory / "manifest.yaml").exists():
+            return self.MANIFEST_ONLY_LANGUAGE_TAG
+        if (connector.code_directory / "setup.py").exists() or (
+            connector.code_directory / consts.PYPROJECT_FILE_NAME
+        ).exists():
+            return self.PYTHON_LANGUAGE_TAG
+        elif (connector.code_directory / "build.gradle").exists() or (
+            connector.code_directory / "build.gradle.kts"
+        ).exists():
+            return self.JAVA_LANGUAGE_TAG
+        else:
+            raise ValueError("Could not infer the language tag from the connector directory")
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        try:
+            expected_language_tag = self.get_expected_language_tag(connector)
+        except ValueError:
+            return self.fail(
+                connector=connector,
+                message="Could not infer the language tag from the connector directory",
+            )
+
+        current_language_tags = [
+            t
+            for t in (connector.metadata.get("tags", []) if connector.metadata else [])
+            if t.startswith("language:")
+        ]
+        if not current_language_tags:
+            return self.fail(
+                connector=connector,
+                message="Language tag is missing in the metadata file",
+            )
+        if len(current_language_tags) > 1:
+            return self.fail(
+                connector=connector,
+                message=f"Multiple language tags found in the metadata file: {current_language_tags}",
+            )
+        current_language_tag = current_language_tags[0]
+        if current_language_tag != expected_language_tag:
+            return self.fail(
+                connector=connector,
+                message=f"Expected language tag '{expected_language_tag}' in the {consts.METADATA_FILE_NAME} file, but found '{current_language_tag}'",
+            )
+        return self.pass_(
+            connector=connector,
+            message=f"Language tag {expected_language_tag} is present in the metadata file",
+        )
+
+
+class CheckConnectorCDKTag(MetadataCheck):
+    """Check that Python connectors have a CDK tag in metadata."""
+
+    name = "Python connectors must have a CDK tag in metadata"
+    description = f"Python connectors must have a CDK tag in their metadata. It must be set in the `tags` field in {consts.METADATA_FILE_NAME}. The values can be `cdk:low-code`, `cdk:python`, or `cdk:file`."
+    applies_to_connector_languages = [ConnectorLanguage.PYTHON, ConnectorLanguage.LOW_CODE]
+
+    class CDKTag:
+        """CDK tag values."""
+
+        LOW_CODE = "cdk:low-code"
+        PYTHON = "cdk:python"
+        FILE = "cdk:python-file-based"
+
+    def get_expected_cdk_tag(self, connector: Connector) -> str:
+        """Get the expected CDK tag for the connector.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            str: The expected CDK tag
+        """
+        manifest_file = (
+            connector.code_directory / connector.technical_name.replace("-", "_") / "manifest.yaml"
+        )
+        pyproject_file = connector.code_directory / consts.PYPROJECT_FILE_NAME
+        setup_py_file = connector.code_directory / "setup.py"
+        if manifest_file.exists():
+            return self.CDKTag.LOW_CODE
+        if pyproject_file.exists():
+            pyproject = toml.load((connector.code_directory / consts.PYPROJECT_FILE_NAME))
+            cdk_deps = pyproject["tool"]["poetry"]["dependencies"].get("airbyte-cdk", None)
+            if (
+                cdk_deps
+                and isinstance(cdk_deps, dict)
+                and "file-based" in cdk_deps.get("extras", [])
+            ):
+                return self.CDKTag.FILE
+        if setup_py_file.exists():
+            if "airbyte-cdk[file-based]" in (connector.code_directory / "setup.py").read_text():
+                return self.CDKTag.FILE
+        return self.CDKTag.PYTHON
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        current_cdk_tags = [
+            t
+            for t in (connector.metadata.get("tags", []) if connector.metadata else [])
+            if t.startswith("cdk:")
+        ]
+        expected_cdk_tag = self.get_expected_cdk_tag(connector)
+        if not current_cdk_tags:
+            return self.fail(
+                connector=connector,
+                message="CDK tag is missing in the metadata file",
+            )
+        if len(current_cdk_tags) > 1:
+            return self.fail(
+                connector=connector,
+                message=f"Multiple CDK tags found in the metadata file: {current_cdk_tags}",
+            )
+        if current_cdk_tags[0] != expected_cdk_tag:
+            return self.fail(
+                connector=connector,
+                message=f"Expected CDK tag '{self.get_expected_cdk_tag(connector)}' in the {consts.METADATA_FILE_NAME} file, but found '{current_cdk_tags[0]}'",
+            )
+        return self.pass_(
+            connector=connector,
+            message=f"CDK tag {self.get_expected_cdk_tag(connector)} is present in the metadata file",
+        )
+
+
+class ValidateBreakingChangesDeadlines(MetadataCheck):
+    """Check that breaking change deadlines are at least a week in the future."""
+
+    name = "Breaking change deadline should be a week in the future"
+    description = "If the connector version has a breaking change, the deadline field must be set to at least a week in the future."
+    runs_on_released_connectors = False
+    minimum_days_until_deadline = 7
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        current_version = connector.version
+        if current_version is None:
+            return self.fail(
+                connector=connector,
+                message="Can't verify breaking changes deadline: connector version is not defined.",
+            )
+
+        breaking_changes = (
+            connector.metadata.get("releases", {}) if connector.metadata else {}
+        ).get("breakingChanges")
+
+        if not breaking_changes:
+            return self.pass_(
+                connector=connector,
+                message="No breaking changes found on this connector.",
+            )
+
+        current_version_breaking_changes = breaking_changes.get(current_version)
+
+        if not current_version_breaking_changes:
+            return self.pass_(
+                connector=connector,
+                message="No breaking changes found for the current version.",
+            )
+
+        upgrade_deadline = current_version_breaking_changes.get("upgradeDeadline")
+
+        if not upgrade_deadline:
+            return self.fail(
+                connector=connector,
+                message=f"No upgrade deadline found for the breaking changes in {current_version}.",
+            )
+
+        upgrade_deadline_datetime = datetime.strptime(upgrade_deadline, "%Y-%m-%d")
+        one_week_from_now = datetime.utcnow() + timedelta(days=self.minimum_days_until_deadline)
+
+        if upgrade_deadline_datetime <= one_week_from_now:
+            return self.fail(
+                connector=connector,
+                message=f"The upgrade deadline for the breaking changes in {current_version} is less than {self.minimum_days_until_deadline} days from today. Please extend the deadline",
+            )
+
+        return self.pass_(
+            connector=connector,
+            message="The upgrade deadline is set to at least a week in the future",
+        )
+
+
+class CheckConnectorMaxSecondsBetweenMessagesValue(MetadataCheck):
+    """Check that certified source connectors have a maxSecondsBetweenMessages value."""
+
+    name = "Certified source connector must have a value filled out for maxSecondsBetweenMessages in metadata"
+    description = "Certified source connectors must have a value filled out for `maxSecondsBetweenMessages` in metadata. This value represents the maximum number of seconds we could expect between messages for API connectors."
+    applies_to_connector_types = ["source"]
+    applies_to_connector_support_levels = ["certified"]
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        max_seconds_between_messages = (
+            connector.metadata.get("maxSecondsBetweenMessages") if connector.metadata else None
+        )
+        if not max_seconds_between_messages:
+            return self.fail(
+                connector=connector,
+                message="Missing required for certified connectors field 'maxSecondsBetweenMessages'",
+            )
+        return self.pass_(
+            connector=connector,
+            message="Value for maxSecondsBetweenMessages is set",
+        )
+
+
+ENABLED_CHECKS = [
+    ValidateMetadata(),
+    CheckConnectorLanguageTag(),
+    CheckConnectorCDKTag(),
+    ValidateBreakingChangesDeadlines(),
+    CheckConnectorMaxSecondsBetweenMessagesValue(),
+]
diff --git a/airbyte_cdk/qa/checks/metadata_test.py b/airbyte_cdk/qa/checks/metadata_test.py
new file mode 100644
index 000000000..f7d3c80e5
--- /dev/null
+++ b/airbyte_cdk/qa/checks/metadata_test.py
@@ -0,0 +1,175 @@
+"""Metadata checks for Airbyte connectors implemented as pytest tests."""
+
+import os
+from datetime import datetime, timedelta
+
+import pytest
+import toml
+import yaml
+
+from airbyte_cdk.qa import consts
+from airbyte_cdk.qa.connector import Connector, ConnectorLanguage
+
+
+@pytest.mark.qa_check
+@pytest.mark.check_category("metadata")
+@pytest.mark.requires_metadata
+class TestMetadata:
+    """Test class for metadata checks."""
+
+    @pytest.mark.parametrize("connector_fixture", ["connector"], indirect=True)
+    def test_validate_metadata(self, connector: Connector) -> None:
+        """Check that connectors have a valid metadata.yaml file.
+
+        Args:
+            connector: The connector to check
+        """
+        assert connector.metadata_file_path.exists(), f"Metadata file {consts.METADATA_FILE_NAME} does not exist"
+        
+        try:
+            with open(connector.metadata_file_path, "r") as f:
+                yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            pytest.fail(f"Metadata file is invalid YAML: {str(e)}")
+
+
+    @pytest.mark.parametrize("connector_fixture", ["connector"], indirect=True)
+    def test_connector_language_tag(self, connector: Connector) -> None:
+        """Check that connectors have a language tag in metadata.
+
+        Args:
+            connector: The connector to check
+        """
+        PYTHON_LANGUAGE_TAG = "language:python"
+        JAVA_LANGUAGE_TAG = "language:java"
+        MANIFEST_ONLY_LANGUAGE_TAG = "language:manifest-only"
+
+        def get_expected_language_tag(connector: Connector) -> str:
+            """Get the expected language tag for the connector.
+
+            Args:
+                connector: The connector to check
+
+            Returns:
+                str: The expected language tag
+
+            Raises:
+                ValueError: If the language tag cannot be inferred
+            """
+            if (connector.code_directory / "manifest.yaml").exists():
+                return MANIFEST_ONLY_LANGUAGE_TAG
+            if (connector.code_directory / "setup.py").exists() or (
+                connector.code_directory / consts.PYPROJECT_FILE_NAME
+            ).exists():
+                return PYTHON_LANGUAGE_TAG
+            elif (connector.code_directory / "build.gradle").exists() or (
+                connector.code_directory / "build.gradle.kts"
+            ).exists():
+                return JAVA_LANGUAGE_TAG
+            else:
+                raise ValueError("Could not infer the language tag from the connector directory")
+
+        try:
+            expected_language_tag = get_expected_language_tag(connector)
+        except ValueError:
+            pytest.fail("Could not infer the language tag from the connector directory")
+
+        current_language_tags = [t for t in (connector.metadata.get("tags", []) if connector.metadata else []) if t.startswith("language:")]
+        assert current_language_tags, "Language tag is missing in the metadata file"
+        assert len(current_language_tags) == 1, f"Multiple language tags found in the metadata file: {current_language_tags}"
+        
+        current_language_tag = current_language_tags[0]
+        assert current_language_tag == expected_language_tag, f"Expected language tag '{expected_language_tag}' in the {consts.METADATA_FILE_NAME} file, but found '{current_language_tag}'"
+
+
+    @pytest.mark.parametrize("connector_fixture", ["connector"], indirect=True)
+    @pytest.mark.connector_language(["python", "low-code"])
+    def test_connector_cdk_tag(self, connector: Connector) -> None:
+        """Check that Python connectors have a CDK tag in metadata.
+
+        Args:
+            connector: The connector to check
+        """
+        class CDKTag:
+            """CDK tag values."""
+
+            LOW_CODE = "cdk:low-code"
+            PYTHON = "cdk:python"
+            FILE = "cdk:python-file-based"
+
+        def get_expected_cdk_tag(connector: Connector) -> str:
+            """Get the expected CDK tag for the connector.
+
+            Args:
+                connector: The connector to check
+
+            Returns:
+                str: The expected CDK tag
+            """
+            manifest_file = connector.code_directory / connector.technical_name.replace("-", "_") / "manifest.yaml"
+            pyproject_file = connector.code_directory / consts.PYPROJECT_FILE_NAME
+            setup_py_file = connector.code_directory / "setup.py"
+            if manifest_file.exists():
+                return CDKTag.LOW_CODE
+            if pyproject_file.exists():
+                pyproject = toml.load((connector.code_directory / consts.PYPROJECT_FILE_NAME))
+                cdk_deps = pyproject["tool"]["poetry"]["dependencies"].get("airbyte-cdk", None)
+                if cdk_deps and isinstance(cdk_deps, dict) and "file-based" in cdk_deps.get("extras", []):
+                    return CDKTag.FILE
+            if setup_py_file.exists():
+                if "airbyte-cdk[file-based]" in (connector.code_directory / "setup.py").read_text():
+                    return CDKTag.FILE
+            return CDKTag.PYTHON
+
+        current_cdk_tags = [t for t in (connector.metadata.get("tags", []) if connector.metadata else []) if t.startswith("cdk:")]
+        expected_cdk_tag = get_expected_cdk_tag(connector)
+        
+        assert current_cdk_tags, "CDK tag is missing in the metadata file"
+        assert len(current_cdk_tags) == 1, f"Multiple CDK tags found in the metadata file: {current_cdk_tags}"
+        assert current_cdk_tags[0] == expected_cdk_tag, f"Expected CDK tag '{get_expected_cdk_tag(connector)}' in the {consts.METADATA_FILE_NAME} file, but found '{current_cdk_tags[0]}'"
+
+
+    @pytest.mark.parametrize("connector_fixture", ["connector"], indirect=True)
+    @pytest.mark.runs_on_released_connectors(False)
+    def test_breaking_changes_deadlines(self, connector: Connector) -> None:
+        """Check that breaking change deadlines are at least a week in the future.
+
+        Args:
+            connector: The connector to check
+        """
+        minimum_days_until_deadline = 7
+        
+        current_version = connector.version
+        assert current_version is not None, "Can't verify breaking changes deadline: connector version is not defined."
+
+        breaking_changes = (connector.metadata.get("releases", {}) if connector.metadata else {}).get("breakingChanges")
+
+        if not breaking_changes:
+            pytest.skip("No breaking changes found on this connector.")
+
+        current_version_breaking_changes = breaking_changes.get(current_version)
+
+        if not current_version_breaking_changes:
+            pytest.skip("No breaking changes found for the current version.")
+
+        upgrade_deadline = current_version_breaking_changes.get("upgradeDeadline")
+
+        assert upgrade_deadline, f"No upgrade deadline found for the breaking changes in {current_version}."
+
+        upgrade_deadline_datetime = datetime.strptime(upgrade_deadline, "%Y-%m-%d")
+        one_week_from_now = datetime.utcnow() + timedelta(days=minimum_days_until_deadline)
+
+        assert upgrade_deadline_datetime > one_week_from_now, f"The upgrade deadline for the breaking changes in {current_version} is less than {minimum_days_until_deadline} days from today. Please extend the deadline"
+
+
+    @pytest.mark.parametrize("connector_fixture", ["connector"], indirect=True)
+    @pytest.mark.connector_type(["source"])
+    @pytest.mark.connector_support_level(["certified"])
+    def test_connector_max_seconds_between_messages_value(self, connector: Connector) -> None:
+        """Check that certified source connectors have a maxSecondsBetweenMessages value.
+
+        Args:
+            connector: The connector to check
+        """
+        max_seconds_between_messages = connector.metadata.get("maxSecondsBetweenMessages") if connector.metadata else None
+        assert max_seconds_between_messages, "Missing required for certified connectors field 'maxSecondsBetweenMessages'"
diff --git a/airbyte_cdk/qa/checks/packaging.py b/airbyte_cdk/qa/checks/packaging.py
new file mode 100644
index 000000000..4cce96be7
--- /dev/null
+++ b/airbyte_cdk/qa/checks/packaging.py
@@ -0,0 +1,360 @@
+"""Packaging checks for Airbyte connectors."""
+
+import semver
+import toml
+from pydash.objects import get
+
+from airbyte_cdk.qa import consts
+from airbyte_cdk.qa.connector import Connector, ConnectorLanguage
+from airbyte_cdk.qa.models import Check, CheckCategory, CheckResult
+
+
+class PackagingCheck(Check):
+    """Base class for packaging checks."""
+
+    category = CheckCategory.PACKAGING
+
+
+class CheckConnectorUsesPoetry(PackagingCheck):
+    """Check that connectors use Poetry for dependency management."""
+
+    name = "Connectors must use Poetry for dependency management"
+    description = "Connectors must use [Poetry](https://python-poetry.org/) for dependency management. This is to ensure that all connectors use a dependency management tool which locks dependencies and ensures reproducible installs."
+    requires_metadata = False
+    runs_on_released_connectors = False
+    applies_to_connector_languages = [
+        ConnectorLanguage.PYTHON,
+        ConnectorLanguage.LOW_CODE,
+    ]
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        if not (connector.code_directory / consts.PYPROJECT_FILE_NAME).exists():
+            return self.create_check_result(
+                connector=connector,
+                passed=False,
+                message=f"{consts.PYPROJECT_FILE_NAME} file is missing",
+            )
+        if not (connector.code_directory / consts.POETRY_LOCK_FILE_NAME).exists():
+            return self.fail(
+                connector=connector, message=f"{consts.POETRY_LOCK_FILE_NAME} file is missing"
+            )
+        if (connector.code_directory / "setup.py").exists():
+            return self.fail(
+                connector=connector,
+                message=f"setup.py file exists. Please remove it and use {consts.PYPROJECT_FILE_NAME} instead",
+            )
+        return self.pass_(
+            connector=connector,
+            message="Poetry is used for dependency management",
+        )
+
+
+class CheckPublishToPyPiIsDeclared(PackagingCheck):
+    """Check that Python connectors have PyPi publishing declared."""
+
+    name = "Python connectors must have PyPi publishing declared."
+    description = f"Python connectors must have [PyPi](https://pypi.org/) publishing enabled in their `{consts.METADATA_FILE_NAME}` file. This is declared by setting `remoteRegistries.pypi.enabled` to `true` in {consts.METADATA_FILE_NAME}. This is to ensure that all connectors can be published to PyPi and can be used in `PyAirbyte`."
+    applies_to_connector_languages = [
+        ConnectorLanguage.PYTHON,
+        ConnectorLanguage.LOW_CODE,
+    ]
+    applies_to_connector_types = ["source"]
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        publish_to_pypi_is_enabled = get(connector.metadata, "remoteRegistries.pypi.enabled")
+        if publish_to_pypi_is_enabled is None:
+            return self.create_check_result(
+                connector=connector,
+                passed=False,
+                message=f"PyPi publishing is not declared. Please set it in the {consts.METADATA_FILE_NAME} file",
+            )
+        return self.create_check_result(
+            connector=connector, passed=True, message="PyPi publishing is declared"
+        )
+
+
+class CheckManifestOnlyConnectorBaseImage(PackagingCheck):
+    """Check that manifest-only connectors use the correct base image."""
+
+    name = "Manifest-only connectors must use `source-declarative-manifest` as their base image"
+    description = "Manifest-only connectors must use `airbyte/source-declarative-manifest` as their base image."
+    applies_to_connector_languages = [ConnectorLanguage.MANIFEST_ONLY]
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        base_image = get(connector.metadata, "connectorBuildOptions.baseImage")
+        base_image_name = base_image.split(":")[0] if base_image else None
+
+        if base_image_name != "docker.io/airbyte/source-declarative-manifest":
+            return self.create_check_result(
+                connector=connector,
+                passed=False,
+                message=f"A manifest-only connector must use `source-declarative-manifest` base image. Replace the base image in {consts.METADATA_FILE_NAME} file",
+            )
+        return self.create_check_result(
+            connector=connector,
+            passed=True,
+            message="Connector uses source-declarative-manifest base image",
+        )
+
+
+class CheckConnectorLicense(PackagingCheck):
+    """Check that connectors are licensed under MIT or Elv2."""
+
+    name = "Connectors must be licensed under MIT or Elv2"
+    description = "Connectors must be licensed under the MIT or Elv2 license. This is to ensure that all connectors are licensed under a permissive license."
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        VALID_LICENSES = ["MIT", "ELV2"]
+        metadata_license = get(connector.metadata, "license")
+        if metadata_license is None:
+            return self.fail(
+                connector=connector,
+                message="License is missing in the metadata file",
+            )
+        elif metadata_license.upper() not in VALID_LICENSES:
+            return self.fail(
+                connector=connector,
+                message=f"Connector is not using a valid license. Please use any of: {', '.join(VALID_LICENSES)}",
+            )
+        else:
+            return self.pass_(
+                connector=connector,
+                message=f"Connector is licensed under {metadata_license}",
+            )
+
+
+class CheckConnectorLicenseMatchInPyproject(PackagingCheck):
+    """Check that connector license in metadata.yaml and pyproject.toml match."""
+
+    name = f"Connector license in {consts.METADATA_FILE_NAME} and {consts.PYPROJECT_FILE_NAME} file must match"
+    description = f"Connectors license in {consts.METADATA_FILE_NAME} and {consts.PYPROJECT_FILE_NAME} file must match. This is to ensure that all connectors are consistently licensed."
+    applies_to_connector_languages = [
+        ConnectorLanguage.PYTHON,
+        ConnectorLanguage.LOW_CODE,
+    ]
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        metadata_license = get(connector.metadata, "license")
+        if metadata_license is None:
+            return self.fail(
+                connector=connector,
+                message=f"License is missing in the {consts.METADATA_FILE_NAME} file",
+            )
+        if not (connector.code_directory / consts.PYPROJECT_FILE_NAME).exists():
+            return self.fail(
+                connector=connector,
+                message=f"{consts.PYPROJECT_FILE_NAME} file is missing",
+            )
+        try:
+            pyproject = toml.load((connector.code_directory / consts.PYPROJECT_FILE_NAME))
+        except toml.TomlDecodeError:
+            return self.fail(
+                connector=connector,
+                message=f"{consts.PYPROJECT_FILE_NAME} is invalid toml file",
+            )
+
+        poetry_license = get(pyproject, "tool.poetry.license")
+
+        if poetry_license is None:
+            return self.fail(
+                connector=connector,
+                message=f"Connector is missing license in {consts.PYPROJECT_FILE_NAME}. Please add it",
+            )
+
+        if poetry_license.lower() != metadata_license.lower():
+            return self.fail(
+                connector=connector,
+                message=f"Connector is licensed under {poetry_license} in {consts.PYPROJECT_FILE_NAME}, but licensed under {metadata_license} in {consts.METADATA_FILE_NAME}. These two files have to be consistent",
+            )
+
+        return self.pass_(
+            connector=connector,
+            message=f"License in {consts.METADATA_FILE_NAME} and {consts.PYPROJECT_FILE_NAME} file match",
+        )
+
+
+class CheckConnectorVersionMatchInPyproject(PackagingCheck):
+    """Check that connector version in metadata.yaml and pyproject.toml match."""
+
+    name = f"Connector version in {consts.METADATA_FILE_NAME} and {consts.PYPROJECT_FILE_NAME} file must match"
+    description = f"Connector version in {consts.METADATA_FILE_NAME} and {consts.PYPROJECT_FILE_NAME} file must match. This is to ensure that connector release is consistent."
+    applies_to_connector_languages = [
+        ConnectorLanguage.PYTHON,
+        ConnectorLanguage.LOW_CODE,
+    ]
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        metadata_version = get(connector.metadata, "dockerImageTag")
+        if metadata_version is None:
+            return self.fail(
+                connector=connector,
+                message=f"dockerImageTag field is missing in the {consts.METADATA_FILE_NAME} file",
+            )
+
+        if not (connector.code_directory / consts.PYPROJECT_FILE_NAME).exists():
+            return self.fail(
+                connector=connector,
+                message=f"{consts.PYPROJECT_FILE_NAME} file is missing",
+            )
+
+        try:
+            pyproject = toml.load((connector.code_directory / consts.PYPROJECT_FILE_NAME))
+        except toml.TomlDecodeError:
+            return self.fail(
+                connector=connector,
+                message=f"{consts.PYPROJECT_FILE_NAME} is invalid toml file",
+            )
+
+        poetry_version = get(pyproject, "tool.poetry.version")
+
+        if poetry_version is None:
+            return self.fail(
+                connector=connector,
+                message=f"Version field is missing in the {consts.PYPROJECT_FILE_NAME} file",
+            )
+
+        if poetry_version != metadata_version:
+            return self.fail(
+                connector=connector,
+                message=f"Version is {metadata_version} in {consts.METADATA_FILE_NAME}, but version is {poetry_version} in {consts.PYPROJECT_FILE_NAME}. These two files have to be consistent",
+            )
+
+        return self.pass_(
+            connector=connector,
+            message=f"Version in {consts.METADATA_FILE_NAME} and {consts.PYPROJECT_FILE_NAME} file match",
+        )
+
+
+class CheckVersionFollowsSemver(PackagingCheck):
+    """Check that connector version follows Semantic Versioning."""
+
+    name = "Connector version must follow Semantic Versioning"
+    description = "Connector version must follow the Semantic Versioning scheme. This is to ensure that all connectors follow a consistent versioning scheme."
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        if not connector.metadata or "dockerImageTag" not in connector.metadata:
+            return self.create_check_result(
+                connector=connector,
+                passed=False,
+                message=f"dockerImageTag is missing in {consts.METADATA_FILE_NAME}",
+            )
+        try:
+            semver.Version.parse(str(connector.metadata["dockerImageTag"]))
+        except ValueError:
+            return self.create_check_result(
+                connector=connector,
+                passed=False,
+                message=f"Connector version {connector.metadata['dockerImageTag']} does not follow semantic versioning",
+            )
+        return self.create_check_result(
+            connector=connector,
+            passed=True,
+            message="Connector version follows semantic versioning",
+        )
+
+
+class CheckVersionBump(PackagingCheck):
+    """Check that connector version has been bumped."""
+
+    name = "Connector version must be bumped"
+    description = "Connector version must be bumped when making changes to the connector. This is to ensure that connector releases are properly versioned."
+    requires_metadata = True
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        if not connector.metadata or "dockerImageTag" not in connector.metadata:
+            return self.create_check_result(
+                connector=connector,
+                passed=False,
+                message=f"dockerImageTag is missing in {consts.METADATA_FILE_NAME}",
+            )
+
+        try:
+            semver.Version.parse(str(connector.metadata["dockerImageTag"]))
+        except ValueError:
+            return self.create_check_result(
+                connector=connector,
+                passed=False,
+                message=f"Connector version {connector.metadata['dockerImageTag']} does not follow semantic versioning",
+            )
+
+        return self.create_check_result(
+            connector=connector,
+            passed=True,
+            message="Connector version is valid. Note: This check does not verify if the version has been bumped from the previous version.",
+        )
+
+
+ENABLED_CHECKS = [
+    CheckConnectorUsesPoetry(),
+    CheckConnectorLicense(),
+    CheckConnectorLicenseMatchInPyproject(),
+    CheckVersionFollowsSemver(),
+    CheckConnectorVersionMatchInPyproject(),
+    CheckPublishToPyPiIsDeclared(),
+    CheckManifestOnlyConnectorBaseImage(),
+    CheckVersionBump(),  # Added version bump check
+]
diff --git a/airbyte_cdk/qa/checks/packaging_test.py b/airbyte_cdk/qa/checks/packaging_test.py
new file mode 100644
index 000000000..c0dab8e63
--- /dev/null
+++ b/airbyte_cdk/qa/checks/packaging_test.py
@@ -0,0 +1,100 @@
+"""Packaging checks for Airbyte connectors implemented as pytest tests."""
+
+import os
+import re
+from pathlib import Path
+
+import pytest
+import semver
+import toml
+import yaml
+
+from airbyte_cdk.qa import consts
+from airbyte_cdk.qa.connector import Connector, ConnectorLanguage
+
+
+@pytest.mark.qa_check
+@pytest.mark.check_category("packaging")
+class TestPackaging:
+    """Test class for packaging checks."""
+
+    @pytest.mark.parametrize("connector_fixture", ["connector"], indirect=True)
+    @pytest.mark.connector_language(["python"])
+    def test_connector_uses_poetry(self, connector: Connector) -> None:
+        """Check that Python connectors use Poetry for dependency management.
+
+        Args:
+            connector: The connector to check
+        """
+        assert connector.pyproject_file_path.exists(), f"Python connector must use Poetry. {consts.PYPROJECT_FILE_NAME} file not found."
+        
+        try:
+            with open(connector.pyproject_file_path, "r") as f:
+                pyproject = toml.load(f)
+        except Exception as e:
+            pytest.fail(f"Failed to parse {consts.PYPROJECT_FILE_NAME}: {str(e)}")
+            
+        assert "tool" in pyproject, f"{consts.PYPROJECT_FILE_NAME} must have a [tool] section"
+        assert "poetry" in pyproject["tool"], f"{consts.PYPROJECT_FILE_NAME} must have a [tool.poetry] section"
+
+
+    @pytest.mark.parametrize("connector_fixture", ["connector"], indirect=True)
+    @pytest.mark.connector_language(["python"])
+    def test_version_bump(self, connector: Connector) -> None:
+        """Check that the connector version has been bumped.
+
+        Args:
+            connector: The connector to check
+        """
+        current_version = connector.version
+        assert current_version is not None, "Could not determine current version from metadata"
+        
+        try:
+            import subprocess
+            
+            cmd = ["git", "show", "HEAD~1:metadata.yaml"]
+            process = subprocess.run(cmd, cwd=connector.code_directory, capture_output=True, text=True)
+            
+            if process.returncode != 0:
+                pytest.skip("Could not get previous version from git history")
+                
+            previous_metadata = yaml.safe_load(process.stdout)
+            previous_version = previous_metadata.get("data", {}).get("dockerImageTag")
+            
+            if not previous_version:
+                pytest.skip("Could not determine previous version from git history")
+                
+            try:
+                current_semver = semver.Version.parse(current_version)
+                previous_semver = semver.Version.parse(previous_version)
+                
+                assert current_semver > previous_semver, f"Version must be bumped. Current: {current_version}, Previous: {previous_version}"
+            except ValueError:
+                assert current_version != previous_version, f"Version must be bumped. Current: {current_version}, Previous: {previous_version}"
+                
+        except Exception as e:
+            pytest.skip(f"Could not check version bump: {str(e)}")
+
+
+    @pytest.mark.parametrize("connector_fixture", ["connector"], indirect=True)
+    @pytest.mark.connector_language(["python"])
+    def test_license_in_pyproject(self, connector: Connector) -> None:
+        """Check that Python connectors have a license in pyproject.toml.
+
+        Args:
+            connector: The connector to check
+        """
+        assert connector.pyproject_file_path.exists(), f"{consts.PYPROJECT_FILE_NAME} file not found"
+        
+        try:
+            with open(connector.pyproject_file_path, "r") as f:
+                pyproject = toml.load(f)
+        except Exception as e:
+            pytest.fail(f"Failed to parse {consts.PYPROJECT_FILE_NAME}: {str(e)}")
+            
+        assert "tool" in pyproject, f"{consts.PYPROJECT_FILE_NAME} must have a [tool] section"
+        assert "poetry" in pyproject["tool"], f"{consts.PYPROJECT_FILE_NAME} must have a [tool.poetry] section"
+        assert "license" in pyproject["tool"]["poetry"], f"{consts.PYPROJECT_FILE_NAME} must have a license field"
+        
+        license_value = pyproject["tool"]["poetry"]["license"]
+        assert license_value.lower() in ["mit", "elv2", "elastic license v2"], f"License must be MIT, ELv2, or Elastic License v2, got {license_value}"
diff --git a/airbyte_cdk/qa/checks/security.py b/airbyte_cdk/qa/checks/security.py
new file mode 100644
index 000000000..d57a5b515
--- /dev/null
+++ b/airbyte_cdk/qa/checks/security.py
@@ -0,0 +1,201 @@
+"""Security checks for Airbyte connectors."""
+
+from pathlib import Path
+from typing import Iterable, Optional, Set, Tuple
+
+from airbyte_cdk.qa import consts
+from airbyte_cdk.qa.connector import Connector, ConnectorLanguage
+from airbyte_cdk.qa.models import Check, CheckCategory, CheckResult
+
+
+class SecurityCheck(Check):
+    """Base class for security checks."""
+
+    category = CheckCategory.SECURITY
+
+
+class CheckConnectorUsesHTTPSOnly(SecurityCheck):
+    """Check that connectors use HTTPS only."""
+
+    name = "Connectors must use HTTPS only"
+    description = "Connectors must use HTTPS only when making requests to external services."
+    requires_metadata = False
+    runs_on_released_connectors = False
+
+    ignore_comment = "# ignore-https-check"  # Define the ignore comment pattern
+
+    ignored_directories_for_https_checks = {
+        ".venv",
+        "tests",
+        "unit_tests",
+        "integration_tests",
+        "test-integration",
+        "build",
+        "source-file",
+        ".pytest_cache",
+        "acceptance_tests_logs",
+        ".hypothesis",
+        ".ruff_cache",
+        "htmlcov",
+    }
+
+    ignored_file_name_pattern_for_https_checks = {
+        "*Test.java",
+        "*.jar",
+        "*.pyc",
+        "*.gz",
+        "*.svg",
+        "expected_records.jsonl",
+        "expected_records.json",
+    }
+
+    ignored_url_prefixes = {
+        "http://json-schema.org",
+        "http://localhost",
+    }
+
+    @staticmethod
+    def _read_all_files_in_directory(
+        directory: Path,
+        ignored_directories: Optional[Set[str]] = None,
+        ignored_filename_patterns: Optional[Set[str]] = None,
+    ) -> Iterable[Tuple[Path, str]]:
+        """Read all files in a directory, ignoring specified directories and filename patterns.
+
+        Args:
+            directory: The directory to read files from
+            ignored_directories: Directories to ignore
+            ignored_filename_patterns: Filename patterns to ignore
+
+        Yields:
+            Tuple[Path, str]: The file path and line content
+        """
+        ignored_directories = ignored_directories if ignored_directories is not None else set()
+        ignored_filename_patterns = (
+            ignored_filename_patterns if ignored_filename_patterns is not None else set()
+        )
+
+        for path in directory.rglob("*"):
+            ignore_directory = any(
+                [ignored_directory in path.parts for ignored_directory in ignored_directories]
+            )
+            ignore_filename = any(
+                [
+                    path.match(ignored_filename_pattern)
+                    for ignored_filename_pattern in ignored_filename_patterns
+                ]
+            )
+            ignore = ignore_directory or ignore_filename
+            if path.is_file() and not ignore:
+                try:
+                    for line in open(path, "r"):
+                        yield path, line
+                except UnicodeDecodeError:
+                    continue
+
+    @staticmethod
+    def _line_is_comment(line: str, file_path: Path) -> bool:
+        """Check if a line is a comment.
+
+        Args:
+            line: The line to check
+            file_path: The file path
+
+        Returns:
+            bool: Whether the line is a comment
+        """
+        language_comments = {
+            ".py": "#",
+            ".yml": "#",
+            ".yaml": "#",
+            ".java": "//",
+            ".md": "<!--",
+        }
+
+        denote_comment = language_comments.get(file_path.suffix)
+        if not denote_comment:
+            return False
+
+        trimmed_line = line.lstrip()
+        return trimmed_line.startswith(denote_comment)
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        files_with_http_url = set()
+
+        for filename, line in self._read_all_files_in_directory(
+            connector.code_directory,
+            self.ignored_directories_for_https_checks,
+            self.ignored_file_name_pattern_for_https_checks,
+        ):
+            line = line.lower()
+            if self._line_is_comment(line, filename):
+                continue
+            if self.ignore_comment in line:
+                continue
+            for prefix in self.ignored_url_prefixes:
+                line = line.replace(prefix, "")
+            if "http://" in line:
+                files_with_http_url.add(str(filename))
+
+        if files_with_http_url:
+            files_with_http_url_message = "\n\t- ".join(files_with_http_url)
+            return self.fail(
+                connector=connector,
+                message=f"The following files have http:// URLs:\n\t- {files_with_http_url_message}",
+            )
+        return self.pass_(connector=connector, message="No file with http:// URLs found")
+
+
+class CheckConnectorUsesPythonBaseImage(SecurityCheck):
+    """Check that Python connectors use the Python connector base image."""
+
+    name = f"Python connectors must not use a Dockerfile and must declare their base image in {consts.METADATA_FILE_NAME} file"
+    description = f"Connectors must use our Python connector base image, declared through the `connectorBuildOptions.baseImage` in their `{consts.METADATA_FILE_NAME}`.\nThis is to ensure that all connectors use a base image which is maintained and has security updates."
+    applies_to_connector_languages = [
+        ConnectorLanguage.PYTHON,
+        ConnectorLanguage.LOW_CODE,
+        ConnectorLanguage.MANIFEST_ONLY,
+    ]
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        dockerfile_path = connector.code_directory / "Dockerfile"
+        if dockerfile_path.exists():
+            return self.create_check_result(
+                connector=connector,
+                passed=False,
+                message=f"Dockerfile file exists. Please remove it and declare the base image in {consts.METADATA_FILE_NAME} file with the `connectorBuildOptions.baseImage` key",
+            )
+
+        base_image = (
+            connector.metadata.get("connectorBuildOptions", {}) if connector.metadata else {}
+        ).get("baseImage")
+        if not base_image:
+            return self.create_check_result(
+                connector=connector,
+                passed=False,
+                message=f"connectorBuildOptions.baseImage key is missing in {consts.METADATA_FILE_NAME} file",
+            )
+        return self.create_check_result(
+            connector=connector,
+            passed=True,
+            message="Connector uses the Python connector base image",
+        )
+
+
+ENABLED_CHECKS = [CheckConnectorUsesHTTPSOnly(), CheckConnectorUsesPythonBaseImage()]
diff --git a/airbyte_cdk/qa/checks/testing.py b/airbyte_cdk/qa/checks/testing.py
new file mode 100644
index 000000000..5c2c44f17
--- /dev/null
+++ b/airbyte_cdk/qa/checks/testing.py
@@ -0,0 +1,46 @@
+"""Testing checks for Airbyte connectors."""
+
+from airbyte_cdk.qa.connector import Connector, ConnectorLanguage
+from airbyte_cdk.qa.models import Check, CheckCategory, CheckResult
+
+
+class TestingCheck(Check):
+    """Base class for testing checks."""
+
+    category = CheckCategory.TESTING
+
+
+class CheckConnectorHasAcceptanceTests(TestingCheck):
+    """Check that connectors have acceptance tests."""
+
+    name = "Connectors must have acceptance tests"
+    description = (
+        "Connectors must have acceptance tests to ensure that they meet the Airbyte specification."
+    )
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        acceptance_test_dir = connector.code_directory / "acceptance-test-config"
+        if not acceptance_test_dir.exists():
+            return self.create_check_result(
+                connector=connector,
+                passed=False,
+                message="Acceptance test directory does not exist",
+            )
+        return self.create_check_result(
+            connector=connector,
+            passed=True,
+            message="Acceptance test directory exists",
+        )
+
+
+ENABLED_CHECKS = [
+    CheckConnectorHasAcceptanceTests(),
+]
diff --git a/airbyte_cdk/qa/connector.py b/airbyte_cdk/qa/connector.py
new file mode 100644
index 000000000..aa716258c
--- /dev/null
+++ b/airbyte_cdk/qa/connector.py
@@ -0,0 +1,285 @@
+"""Connector utilities for QA checks."""
+
+import json
+import os
+import re
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import yaml
+
+
+class ConnectorLanguage(Enum):
+    """The programming language of a connector."""
+
+    PYTHON = "python"
+    JAVA = "java"
+    LOW_CODE = "low-code"
+    MANIFEST_ONLY = "manifest-only"
+
+
+class ConnectorLanguageError(Exception):
+    """Raised when the connector language cannot be determined."""
+
+    pass
+
+
+class Connector:
+    """A class representing an Airbyte connector.
+
+    This is a simplified version of the Connector class from connector_ops.utils,
+    with only the functionality needed for QA checks.
+    """
+
+    def __init__(self, technical_name: str, connector_directory: Optional[Path] = None):
+        """Initialize a Connector instance.
+
+        Args:
+            technical_name: The technical name of the connector (e.g. "source-postgres")
+            connector_directory: The directory containing the connector code. If not provided,
+                it will be inferred from the technical name.
+        """
+        self._technical_name = technical_name
+        self._connector_directory = connector_directory
+        self._metadata_cache: Optional[Dict[str, Any]] = None
+        self._is_released: Optional[bool] = None
+
+    def __repr__(self) -> str:
+        """Return a string representation of the connector.
+
+        Returns:
+            str: A string representation of the connector
+        """
+        return self.technical_name
+
+    @property
+    def technical_name(self) -> str:
+        """The technical name of the connector.
+
+        Returns:
+            str: The technical name of the connector
+        """
+        return self._technical_name
+
+    @property
+    def name(self) -> str:
+        """The name of the connector.
+
+        Returns:
+            str: The name of the connector
+        """
+        return self.technical_name
+
+    @property
+    def connector_type(self) -> str:
+        """The type of the connector (source or destination).
+
+        Returns:
+            str: The type of the connector
+        """
+        return self.technical_name.split("-")[0]
+
+    @property
+    def is_third_party(self) -> bool:
+        """Whether the connector is third-party.
+
+        Returns:
+            bool: Whether the connector is third-party
+        """
+        return False  # Simplified for now
+
+    @property
+    def code_directory(self) -> Path:
+        """The directory containing the connector code.
+
+        Returns:
+            Path: The directory containing the connector code
+        """
+        if self._connector_directory:
+            return self._connector_directory
+
+        cwd = Path.cwd()
+        if cwd.name == self.technical_name:
+            return cwd
+
+        for parent in cwd.parents:
+            if parent.name == self.technical_name:
+                return parent
+
+        return cwd
+
+    @property
+    def metadata_file_path(self) -> Path:
+        """The path to the metadata.yaml file.
+
+        Returns:
+            Path: The path to the metadata.yaml file
+        """
+        return self.code_directory / "metadata.yaml"
+
+    @property
+    def metadata(self) -> Optional[Dict[str, Any]]:
+        """The metadata from the metadata.yaml file.
+
+        Returns:
+            Dict[str, Any]: The metadata from the metadata.yaml file, or None if the file doesn't exist
+        """
+        if self._metadata_cache is not None:
+            return self._metadata_cache
+
+        if not self.metadata_file_path.exists():
+            return None
+
+        with open(self.metadata_file_path, "r") as f:
+            self._metadata_cache = yaml.safe_load(f)
+        return self._metadata_cache
+
+    @property
+    def language(self) -> Optional[ConnectorLanguage]:
+        """The programming language of the connector.
+
+        Returns:
+            ConnectorLanguage: The programming language of the connector
+        """
+        if (
+            Path(self.code_directory / "setup.py").exists()
+            or Path(self.code_directory / "pyproject.toml").exists()
+        ):
+            return ConnectorLanguage.PYTHON
+        if (
+            Path(self.code_directory / "src" / "main" / "java").exists()
+            or Path(self.code_directory / "src" / "main" / "kotlin").exists()
+        ):
+            return ConnectorLanguage.JAVA
+        if self.manifest_path.exists():
+            return ConnectorLanguage.LOW_CODE
+        return None
+
+    @property
+    def manifest_path(self) -> Path:
+        """The path to the manifest.yaml file.
+
+        Returns:
+            Path: The path to the manifest.yaml file
+        """
+        return self.code_directory / "manifest.yaml"
+
+    @property
+    def version(self) -> Optional[str]:
+        """The version of the connector.
+
+        Returns:
+            str: The version of the connector, or None if it can't be determined
+        """
+        if self.metadata:
+            docker_image_tag = self.metadata.get("data", {}).get("dockerImageTag")
+            return str(docker_image_tag) if docker_image_tag is not None else None
+        return None
+
+    @property
+    def version_in_dockerfile_label(self) -> Optional[str]:
+        """The version of the connector from the Dockerfile label.
+
+        Returns:
+            str: The version of the connector from the Dockerfile label, or None if it can't be determined
+        """
+        dockerfile_path = self.code_directory / "Dockerfile"
+        if not dockerfile_path.exists():
+            return None
+
+        with open(dockerfile_path, "r") as f:
+            dockerfile_content = f.read()
+
+        version_match = re.search(r'LABEL io.airbyte.version="([^"]+)"', dockerfile_content)
+        if version_match:
+            return version_match.group(1)
+        return None
+
+    @property
+    def name_from_metadata(self) -> Optional[str]:
+        """The name of the connector from the metadata.
+
+        Returns:
+            str: The name of the connector from the metadata, or None if it can't be determined
+        """
+        if self.metadata:
+            name = self.metadata.get("data", {}).get("name")
+            return str(name) if name is not None else None
+        return None
+
+    @property
+    def support_level(self) -> Optional[str]:
+        """The support level of the connector.
+
+        Returns:
+            str: The support level of the connector, or None if it can't be determined
+        """
+        if self.metadata:
+            support_level = self.metadata.get("data", {}).get("supportLevel")
+            return str(support_level) if support_level is not None else None
+        return None
+
+    @property
+    def cloud_usage(self) -> Optional[str]:
+        """The cloud usage of the connector.
+
+        Returns:
+            str: The cloud usage of the connector, or None if it can't be determined
+        """
+        if self.metadata:
+            cloud_usage = self.metadata.get("data", {}).get("cloudUsage")
+            return str(cloud_usage) if cloud_usage is not None else None
+        return None
+
+    @property
+    def ab_internal_sl(self) -> int:
+        """The ab_internal_sl of the connector.
+
+        Returns:
+            int: The ab_internal_sl of the connector, or 0 if it can't be determined
+        """
+        if self.metadata:
+            sl_value = self.metadata.get("data", {}).get("ab_internal", {}).get("sl", 0)
+            return int(sl_value) if sl_value is not None else 0
+        return 0
+
+    @property
+    def is_released(self) -> bool:
+        """Whether the connector is released.
+
+        Returns:
+            bool: Whether the connector is released
+        """
+        if self._is_released is not None:
+            return self._is_released
+
+        self._is_released = True
+        return True
+
+    @property
+    def pyproject_file_path(self) -> Path:
+        """The path to the pyproject.toml file.
+
+        Returns:
+            Path: The path to the pyproject.toml file
+        """
+        return self.code_directory / "pyproject.toml"
+
+    @property
+    def dockerfile_file_path(self) -> Path:
+        """The path to the Dockerfile.
+
+        Returns:
+            Path: The path to the Dockerfile
+        """
+        return self.code_directory / "Dockerfile"
+
+    @property
+    def has_dockerfile(self) -> bool:
+        """Whether the connector has a Dockerfile.
+
+        Returns:
+            bool: Whether the connector has a Dockerfile
+        """
+        return self.dockerfile_file_path.exists()
diff --git a/airbyte_cdk/qa/consts.py b/airbyte_cdk/qa/consts.py
new file mode 100644
index 000000000..1bc62e70e
--- /dev/null
+++ b/airbyte_cdk/qa/consts.py
@@ -0,0 +1,10 @@
+"""Constants for QA checks."""
+
+METADATA_FILE_NAME = "metadata.yaml"
+MANIFEST_FILE_NAME = "manifest.yaml"
+COMPONENTS_FILE_NAME = "components.py"
+DOCKERFILE_FILE_NAME = "Dockerfile"
+PYPROJECT_FILE_NAME = "pyproject.toml"
+ICON_FILE_NAME = "icon.svg"
+POETRY_LOCK_FILE_NAME = "poetry.lock"
+CONNECTORS_QA_DOC_TEMPLATE_NAME = "connectors_qa_doc.md.j2"
diff --git a/airbyte_cdk/qa/models.py b/airbyte_cdk/qa/models.py
new file mode 100644
index 000000000..5c21109ef
--- /dev/null
+++ b/airbyte_cdk/qa/models.py
@@ -0,0 +1,379 @@
+from __future__ import annotations
+
+import json
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from airbyte_cdk.qa.connector import Connector, ConnectorLanguage
+
+ALL_LANGUAGES = [
+    ConnectorLanguage.JAVA,
+    ConnectorLanguage.LOW_CODE,
+    ConnectorLanguage.PYTHON,
+    ConnectorLanguage.MANIFEST_ONLY,
+]
+
+ALL_TYPES = ["source", "destination"]
+
+
+class CheckCategory(Enum):
+    """The category of a QA check."""
+
+    PACKAGING = "📦 Packaging"
+    DOCUMENTATION = "📄 Documentation"
+    ASSETS = "💼 Assets"
+    SECURITY = "🔒 Security"
+    METADATA = "📝 Metadata"
+    TESTING = "🧪 Testing"
+
+
+class CheckStatus(Enum):
+    """The status of a QA check."""
+
+    PASSED = "✅ Passed"
+    FAILED = "❌ Failed"
+    SKIPPED = "🔶 Skipped"
+
+
+@dataclass
+class CheckResult:
+    """The result of a QA check.
+
+    Attributes:
+        check: The QA check that was run
+        connector: The connector that was checked
+        status: The status of the check
+        message: A message explaining the result of the check
+    """
+
+    check: Check
+    connector: Connector
+    status: CheckStatus
+    message: str
+
+    def __repr__(self) -> str:
+        return f"{self.connector} - {self.status.value} - {self.check.name}: {self.message}."
+
+
+class Check(ABC):
+    """Base class for all QA checks.
+
+    This abstract class defines the interface for all QA checks. Subclasses must implement
+    the name, description, category, and _run methods.
+    """
+
+    requires_metadata: bool = True
+    runs_on_released_connectors: bool = True
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """The name of the QA check.
+
+        Raises:
+            NotImplementedError: Subclasses must implement name property/attribute
+
+        Returns:
+            str: The name of the QA check
+        """
+        raise NotImplementedError("Subclasses must implement name property/attribute")
+
+    @property
+    def required(self) -> bool:
+        """Whether the QA check is required.
+
+        Returns:
+            bool: Whether the QA check is required
+        """
+        return True
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """A full description of the QA check. Used for documentation purposes.
+
+        It can use markdown syntax.
+
+        Raises:
+            NotImplementedError: Subclasses must implement description property/attribute
+
+        Returns:
+            str: The description of the QA check
+        """
+        raise NotImplementedError("Subclasses must implement description property/attribute")
+
+    @property
+    def applies_to_connector_languages(self) -> List[ConnectorLanguage]:
+        """The connector languages that the QA check applies to.
+
+        Returns:
+            List[ConnectorLanguage]: The connector languages that the QA check applies to
+        """
+        return ALL_LANGUAGES
+
+    @property
+    def applies_to_connector_types(self) -> List[str]:
+        """The connector types that the QA check applies to.
+
+        Returns:
+            List[str]: The connector types that the QA check applies to
+        """
+        return ALL_TYPES
+
+    @property
+    def applies_to_connector_ab_internal_sl(self) -> int:
+        """The connector ab_internal_s that the QA check applies to.
+
+        Returns:
+            int: integer value for connector ab_internal_sl level
+        """
+        return 0
+
+    @property
+    @abstractmethod
+    def category(self) -> CheckCategory:
+        """The category of the QA check.
+
+        Raises:
+            NotImplementedError: Subclasses must implement category property/attribute
+
+        Returns:
+            CheckCategory: The category of the QA check
+        """
+        raise NotImplementedError("Subclasses must implement category property/attribute")
+
+    @property
+    def applies_to_connector_support_levels(self) -> Optional[List[str]]:
+        """The connector's support levels that the QA check applies to.
+
+        Returns:
+            List[str]: None if connector's support levels that the QA check applies to is not specified
+        """
+        return None
+
+    @property
+    def applies_to_connector_cloud_usage(self) -> Optional[List[str]]:
+        """The connector's cloud usage level that the QA check applies to.
+
+        Returns:
+            List[str]: None if connector's cloud usage levels that the QA check applies to is not specified
+        """
+        return None
+
+    def run(self, connector: Connector) -> CheckResult:
+        """Run the QA check on the given connector.
+
+        Args:
+            connector: The connector to run the check on
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        if not self.runs_on_released_connectors and connector.is_released:
+            return self.skip(
+                connector,
+                "Check does not apply to released connectors",
+            )
+        if not connector.metadata and self.requires_metadata:
+            return self.fail(
+                connector,
+                "This checks requires metadata file to run. Please add metadata.yaml file to the connector code directory.",
+            )
+        if not connector.language:
+            return self.fail(connector, "Connector language could not be inferred")
+        if connector.language not in self.applies_to_connector_languages:
+            return self.skip(
+                connector,
+                f"Check does not apply to {connector.language.value} connectors",
+            )
+        if connector.connector_type not in self.applies_to_connector_types:
+            return self.skip(
+                connector,
+                f"Check does not apply to {connector.connector_type} connectors",
+            )
+        if (
+            self.applies_to_connector_support_levels
+            and connector.support_level not in self.applies_to_connector_support_levels
+        ):
+            return self.skip(
+                connector,
+                f"Check does not apply to {connector.support_level} connectors",
+            )
+        if (
+            self.applies_to_connector_cloud_usage
+            and connector.cloud_usage not in self.applies_to_connector_cloud_usage
+        ):
+            return self.skip(
+                connector,
+                f"Check does not apply to {connector.cloud_usage} connectors",
+            )
+        if connector.ab_internal_sl < self.applies_to_connector_ab_internal_sl:
+            return self.skip(
+                connector,
+                f"Check does not apply to connectors with sl < {self.applies_to_connector_ab_internal_sl}",
+            )
+        return self._run(connector)
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the actual check logic.
+
+        This method must be implemented by subclasses.
+
+        Args:
+            connector: The connector to run the check on
+
+        Raises:
+            NotImplementedError: Subclasses must implement _run method
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        raise NotImplementedError("Subclasses must implement _run method")
+
+    def pass_(self, connector: Connector, message: str) -> CheckResult:
+        """Create a passing check result.
+
+        Args:
+            connector: The connector that was checked
+            message: A message explaining why the check passed
+
+        Returns:
+            CheckResult: A passing check result
+        """
+        return CheckResult(
+            connector=connector, check=self, status=CheckStatus.PASSED, message=message
+        )
+
+    def fail(self, connector: Connector, message: str) -> CheckResult:
+        """Create a failing check result.
+
+        Args:
+            connector: The connector that was checked
+            message: A message explaining why the check failed
+
+        Returns:
+            CheckResult: A failing check result
+        """
+        return CheckResult(
+            connector=connector, check=self, status=CheckStatus.FAILED, message=message
+        )
+
+    def skip(self, connector: Connector, reason: str) -> CheckResult:
+        """Create a skipped check result.
+
+        Args:
+            connector: The connector that was checked
+            reason: A reason explaining why the check was skipped
+
+        Returns:
+            CheckResult: A skipped check result
+        """
+        return CheckResult(
+            connector=connector, check=self, status=CheckStatus.SKIPPED, message=reason
+        )
+
+    def create_check_result(self, connector: Connector, passed: bool, message: str) -> CheckResult:
+        """Create a check result based on whether the check passed or failed.
+
+        Args:
+            connector: The connector that was checked
+            passed: Whether the check passed
+            message: A message explaining the result of the check
+
+        Returns:
+            CheckResult: The check result
+        """
+        status = CheckStatus.PASSED if passed else CheckStatus.FAILED
+        return CheckResult(check=self, connector=connector, status=status, message=message)
+
+
+@dataclass
+class Report:
+    """The report of a QA run.
+
+    Attributes:
+        check_results: The results of the QA checks
+    """
+
+    badge_name = "Connector QA Checks"
+    check_results: list[CheckResult]
+    image_shield_root_url = "https://img.shields.io/badge"
+
+    def write(self, output_file: Path) -> None:
+        """Write the report to a file.
+
+        Args:
+            output_file: The file to write the report to
+        """
+        output_file.write_text(self.to_json())
+
+    def to_json(self) -> str:
+        """Convert the report to a JSON-serializable dictionary.
+
+        Returns:
+            str: The report as a JSON string
+        """
+        connectors_report: Dict[str, Dict[str, Any]] = {}
+        for check_result in self.check_results:
+            connector = check_result.connector
+            connectors_report.setdefault(
+                connector.technical_name,
+                {
+                    "failed_checks": [],
+                    "skipped_checks": [],
+                    "passed_checks": [],
+                    "failed_checks_count": 0,
+                    "skipped_checks_count": 0,
+                    "successful_checks_count": 0,
+                    "total_checks_count": 0,
+                },
+            )
+            check_name_and_message = {
+                "check": check_result.check.name,
+                "message": check_result.message,
+            }
+            if check_result.status == CheckStatus.PASSED:
+                connectors_report[connector.technical_name]["passed_checks"].append(
+                    check_name_and_message
+                )
+                connectors_report[connector.technical_name]["successful_checks_count"] += 1
+                connectors_report[connector.technical_name]["total_checks_count"] += 1
+
+            elif check_result.status == CheckStatus.FAILED:
+                connectors_report[connector.technical_name]["failed_checks"].append(
+                    check_name_and_message
+                )
+                connectors_report[connector.technical_name]["failed_checks_count"] += 1
+                connectors_report[connector.technical_name]["total_checks_count"] += 1
+
+            elif check_result.status == CheckStatus.SKIPPED:
+                connectors_report[connector.technical_name]["skipped_checks"].append(
+                    check_name_and_message
+                )
+                connectors_report[connector.technical_name]["skipped_checks_count"] += 1
+            else:
+                raise ValueError(f"Invalid check status {check_result.status}")
+        for connector_technical_name in connectors_report.keys():
+            connectors_report[connector_technical_name]["badge_color"] = (
+                "red"
+                if connectors_report[connector_technical_name]["failed_checks_count"] > 0
+                else "green"
+            )
+            badge_name = self.badge_name.replace(" ", "_")
+            badge_text = f"{connectors_report[connector_technical_name]['successful_checks_count']}/{connectors_report[connector_technical_name]['total_checks_count']}".replace(
+                " ", "_"
+            )
+            connectors_report[connector_technical_name]["badge_text"] = badge_text
+            connectors_report[connector_technical_name]["badge_url"] = (
+                f"{self.image_shield_root_url}/{badge_name}-{badge_text}-{connectors_report[connector_technical_name]['badge_color']}"
+            )
+        return json.dumps(
+            {
+                "generation_timestamp": datetime.utcnow().isoformat(),
+                "connectors": connectors_report,
+            }
+        )
diff --git a/airbyte_cdk/qa/py.typed b/airbyte_cdk/qa/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/airbyte_cdk/qa/pytest_plugin/__init__.py b/airbyte_cdk/qa/pytest_plugin/__init__.py
new file mode 100644
index 000000000..be74cf7cb
--- /dev/null
+++ b/airbyte_cdk/qa/pytest_plugin/__init__.py
@@ -0,0 +1,17 @@
+"""Pytest plugin for running QA checks on connectors."""
+
+from airbyte_cdk.qa.pytest_plugin.plugin import (
+    connector,
+    pytest_addoption,
+    pytest_collection_modifyitems,
+    pytest_configure,
+    pytest_sessionfinish,
+)
+
+__all__ = [
+    "connector",
+    "pytest_addoption",
+    "pytest_collection_modifyitems",
+    "pytest_configure",
+    "pytest_sessionfinish",
+]
diff --git a/airbyte_cdk/qa/pytest_plugin/plugin.py b/airbyte_cdk/qa/pytest_plugin/plugin.py
new file mode 100644
index 000000000..68301ada9
--- /dev/null
+++ b/airbyte_cdk/qa/pytest_plugin/plugin.py
@@ -0,0 +1,187 @@
+"""Pytest plugin for running QA checks on connectors."""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pytest
+from _pytest.config import Config
+from _pytest.config.argparsing import Parser
+from _pytest.main import Session
+from _pytest.python import Function, Module
+
+from airbyte_cdk.qa.connector import Connector
+
+
+def pytest_addoption(parser: Parser) -> None:
+    """Add command-line options for the QA checks plugin.
+
+    Args:
+        parser: The pytest command-line parser
+    """
+    group = parser.getgroup("airbyte-qa")
+    group.addoption(
+        "--connector-name",
+        action="store",
+        dest="connector_name",
+        help="Name of the connector to check",
+    )
+    group.addoption(
+        "--connector-directory",
+        action="store",
+        dest="connector_directory",
+        type=Path,
+        help="Path to the connector directory",
+    )
+    group.addoption(
+        "--report-path",
+        action="store",
+        dest="report_path",
+        type=Path,
+        help="Path to write the report to",
+    )
+
+
+@pytest.fixture(scope="session")
+def connector(request: pytest.FixtureRequest) -> Connector:
+    """Fixture for the connector under test.
+
+    Args:
+        request: The pytest request object
+
+    Returns:
+        Connector: The connector under test
+    """
+    connector_name = request.config.getoption("connector_name")
+    connector_directory = request.config.getoption("connector_directory")
+    
+    if not connector_name and not connector_directory:
+        cwd = Path.cwd()
+        if cwd.name.startswith("source-") or cwd.name.startswith("destination-"):
+            connector_name = cwd.name
+            connector_directory = cwd
+        else:
+            for parent in cwd.parents:
+                if parent.name.startswith("source-") or parent.name.startswith("destination-"):
+                    connector_name = parent.name
+                    connector_directory = parent
+                    break
+    
+    if not connector_name and not connector_directory:
+        pytest.fail("Could not determine connector name or directory. Please provide --connector-name or --connector-directory.")
+    
+    return Connector(connector_name, connector_directory)
+
+
+class QACheckFunction(Function):
+    """A pytest Function that represents a QA check."""
+
+    def __init__(self, *args, check_name: str, check_description: str, **kwargs):
+        """Initialize a QACheckFunction.
+
+        Args:
+            check_name: The name of the check
+            check_description: The description of the check
+            *args: Additional positional arguments
+            **kwargs: Additional keyword arguments
+        """
+        super().__init__(*args, **kwargs)
+        self.check_name = check_name
+        self.check_description = check_description
+        
+    def _getdocstring(self) -> Optional[str]:
+        """Get the docstring for the check.
+
+        Returns:
+            Optional[str]: The docstring for the check
+        """
+        return self.check_description
+
+
+def pytest_configure(config: Config) -> None:
+    """Configure pytest for the QA checks plugin.
+
+    Args:
+        config: The pytest config object
+    """
+    config.addinivalue_line("markers", "qa_check: mark a test as a QA check")
+    config.addinivalue_line("markers", "check_category(category): mark a test with a check category")
+    config.addinivalue_line("markers", "connector_language(languages): mark a test as applicable to specific connector languages")
+    config.addinivalue_line("markers", "connector_type(types): mark a test as applicable to specific connector types")
+    config.addinivalue_line("markers", "connector_support_level(levels): mark a test as applicable to specific connector support levels")
+    config.addinivalue_line("markers", "connector_cloud_usage(usages): mark a test as applicable to specific connector cloud usages")
+    config.addinivalue_line("markers", "connector_ab_internal_sl(sl): mark a test as applicable to connectors with a specific ab_internal_sl")
+    config.addinivalue_line("markers", "requires_metadata: mark a test as requiring metadata")
+    config.addinivalue_line("markers", "runs_on_released_connectors: mark a test as running on released connectors")
+
+
+def pytest_collection_modifyitems(config: Config, items: List[pytest.Item]) -> None:
+    """Modify the collected test items to filter based on connector properties.
+
+    Args:
+        config: The pytest config object
+        items: The collected test items
+    """
+    connector_name = config.getoption("connector_name")
+    connector_directory = config.getoption("connector_directory")
+    
+    if not connector_name and not connector_directory:
+        return
+    
+    connector_obj = Connector(connector_name, connector_directory)
+    
+    for item in items:
+        if not item.get_closest_marker("qa_check"):
+            continue
+        
+        if item.get_closest_marker("requires_metadata") and not connector_obj.metadata:
+            item.add_marker(pytest.mark.skip(reason="This check requires metadata file to run"))
+            continue
+            
+        if item.get_closest_marker("runs_on_released_connectors") is None and connector_obj.is_released:
+            item.add_marker(pytest.mark.skip(reason="Check does not apply to released connectors"))
+            continue
+            
+        if not connector_obj.language:
+            item.add_marker(pytest.mark.skip(reason="Connector language could not be inferred"))
+            continue
+            
+        languages_marker = item.get_closest_marker("connector_language")
+        if languages_marker and connector_obj.language.value not in languages_marker.args[0]:
+            item.add_marker(pytest.mark.skip(reason=f"Check does not apply to {connector_obj.language.value} connectors"))
+            continue
+            
+        types_marker = item.get_closest_marker("connector_type")
+        if types_marker and connector_obj.connector_type not in types_marker.args[0]:
+            item.add_marker(pytest.mark.skip(reason=f"Check does not apply to {connector_obj.connector_type} connectors"))
+            continue
+            
+        support_levels_marker = item.get_closest_marker("connector_support_level")
+        if support_levels_marker and connector_obj.support_level not in support_levels_marker.args[0]:
+            item.add_marker(pytest.mark.skip(reason=f"Check does not apply to {connector_obj.support_level} connectors"))
+            continue
+            
+        cloud_usage_marker = item.get_closest_marker("connector_cloud_usage")
+        if cloud_usage_marker and connector_obj.cloud_usage not in cloud_usage_marker.args[0]:
+            item.add_marker(pytest.mark.skip(reason=f"Check does not apply to {connector_obj.cloud_usage} connectors"))
+            continue
+            
+        ab_internal_sl_marker = item.get_closest_marker("connector_ab_internal_sl")
+        if ab_internal_sl_marker and connector_obj.ab_internal_sl < ab_internal_sl_marker.args[0]:
+            item.add_marker(pytest.mark.skip(reason=f"Check does not apply to connectors with sl < {ab_internal_sl_marker.args[0]}"))
+            continue
+
+
+def pytest_sessionfinish(session: Session, exitstatus: int) -> None:
+    """Generate a report at the end of the test session.
+
+    Args:
+        session: The pytest session
+        exitstatus: The exit status of the session
+    """
+    report_path = session.config.getoption("report_path")
+    if not report_path:
+        return
+    
+    report_path = Path(report_path)
+    report_path.write_text("{}")
diff --git a/airbyte_cdk/qa/utils.py b/airbyte_cdk/qa/utils.py
new file mode 100644
index 000000000..1c18cd233
--- /dev/null
+++ b/airbyte_cdk/qa/utils.py
@@ -0,0 +1,38 @@
+"""Utilities for QA checks."""
+
+from pathlib import Path
+from typing import List
+
+from airbyte_cdk.qa.connector import Connector
+
+
+def get_all_connectors_in_directory(directory: Path) -> List[Connector]:
+    """Get all connectors in a directory.
+
+    Args:
+        directory: The directory to search for connectors
+
+    Returns:
+        List[Connector]: The connectors found in the directory
+    """
+    connectors = []
+    for path in directory.iterdir():
+        if path.is_dir() and (
+            path.name.startswith("source-") or path.name.startswith("destination-")
+        ):
+            connectors.append(Connector(path.name, path))
+    return connectors
+
+
+def remove_strict_encrypt_suffix(connector_name: str) -> str:
+    """Remove the strict-encrypt suffix from a connector name.
+
+    Args:
+        connector_name: The connector name
+
+    Returns:
+        str: The connector name without the strict-encrypt suffix
+    """
+    if connector_name.endswith("-strict-encrypt"):
+        return connector_name[:-14]
+    return connector_name
diff --git a/poetry.lock b/poetry.lock
index e031efb6b..4f96f8aba 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 2.1.2 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.0.1 and should not be changed by hand.
 
 [[package]]
 name = "aiohappyeyeballs"
@@ -7,7 +7,7 @@ description = "Happy Eyeballs for asyncio"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "aiohappyeyeballs-2.4.4-py3-none-any.whl", hash = "sha256:a980909d50efcd44795c4afeca523296716d50cd756ddca6af8c65b996e27de8"},
     {file = "aiohappyeyeballs-2.4.4.tar.gz", hash = "sha256:5fdd7d87889c63183afc18ce9271f9b0a7d32c2303e394468dd45d514a757745"},
@@ -20,7 +20,7 @@ description = "Async http client/server framework (asyncio)"
 optional = true
 python-versions = ">=3.9"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "aiohttp-3.11.11-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a60804bff28662cbcf340a4d61598891f12eea3a66af48ecfdc975ceec21e3c8"},
     {file = "aiohttp-3.11.11-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:4b4fa1cb5f270fb3eab079536b764ad740bb749ce69a94d4ec30ceee1b5940d5"},
@@ -111,7 +111,7 @@ propcache = ">=0.2.0"
 yarl = ">=1.17.0,<2.0"
 
 [package.extras]
-speedups = ["Brotli ; platform_python_implementation == \"CPython\"", "aiodns (>=3.2.0) ; sys_platform == \"linux\" or sys_platform == \"darwin\"", "brotlicffi ; platform_python_implementation != \"CPython\""]
+speedups = ["Brotli", "aiodns (>=3.2.0)", "brotlicffi"]
 
 [[package]]
 name = "aiosignal"
@@ -120,7 +120,7 @@ description = "aiosignal: a list of registered asynchronous callbacks"
 optional = true
 python-versions = ">=3.9"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "aiosignal-1.3.2-py2.py3-none-any.whl", hash = "sha256:45cde58e409a301715980c2b01d0c28bdde3770d8290b5eb2173759d9acb31a5"},
     {file = "aiosignal-1.3.2.tar.gz", hash = "sha256:a8c255c66fafb1e499c9351d0bf32ff2d8a0321595ebac3b93713656d2436f54"},
@@ -136,6 +136,7 @@ description = "Declares the Airbyte Protocol using Python Dataclasses. Dataclass
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "airbyte_protocol_models_dataclasses-0.15.0-py3-none-any.whl", hash = "sha256:0fe8d7c2863c348b350efcf5f1af5872dc9071060408285e4708d97a9be5e2fb"},
     {file = "airbyte_protocol_models_dataclasses-0.15.0.tar.gz", hash = "sha256:a5bad4ee7ae0a04f1436967b7afd3306d28e1cd2e5acedf0cce588f0c80ed001"},
@@ -148,6 +149,7 @@ description = "Reusable constraint types to use with typing.Annotated"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"},
     {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"},
@@ -160,6 +162,7 @@ description = "Unicode to ASCII transliteration"
 optional = false
 python-versions = ">=3.3"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "anyascii-0.3.2-py3-none-any.whl", hash = "sha256:3b3beef6fc43d9036d3b0529050b0c48bfad8bc960e9e562d7223cfb94fe45d4"},
     {file = "anyascii-0.3.2.tar.gz", hash = "sha256:9d5d32ef844fe225b8bc7cba7f950534fae4da27a9bf3a6bea2cb0ea46ce4730"},
@@ -172,6 +175,7 @@ description = "High level compatibility layer for multiple asynchronous event lo
 optional = true
 python-versions = ">=3.9"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "anyio-4.8.0-py3-none-any.whl", hash = "sha256:b5011f270ab5eb0abf13385f851315585cc37ef330dd88e27ec3d34d651fd47a"},
     {file = "anyio-4.8.0.tar.gz", hash = "sha256:1d9fe889df5212298c0c0723fa20479d1b94883a2df44bd3897aa91083316f7a"},
@@ -185,7 +189,7 @@ typing_extensions = {version = ">=4.5", markers = "python_version < \"3.13\""}
 
 [package.extras]
 doc = ["Sphinx (>=7.4,<8.0)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx_rtd_theme"]
-test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "trustme", "truststore (>=0.9.1) ; python_version >= \"3.10\"", "uvloop (>=0.21) ; platform_python_implementation == \"CPython\" and platform_system != \"Windows\" and python_version < \"3.14\""]
+test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "trustme", "truststore (>=0.9.1)", "uvloop (>=0.21)"]
 trio = ["trio (>=0.26.1)"]
 
 [[package]]
@@ -195,7 +199,7 @@ description = "Timeout context manager for asyncio programs"
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
-markers = "extra == \"vector-db-based\" and python_version == \"3.10\""
+markers = "extra == \"vector-db-based\" and python_version < \"3.11\""
 files = [
     {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"},
     {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"},
@@ -208,6 +212,7 @@ description = "reference implementation of PEP 3156"
 optional = false
 python-versions = "*"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "asyncio-3.4.3-cp33-none-win32.whl", hash = "sha256:b62c9157d36187eca799c378e572c969f0da87cd5fc42ca372d92cdb06e7e1de"},
     {file = "asyncio-3.4.3-cp33-none-win_amd64.whl", hash = "sha256:c46a87b48213d7464f22d9a497b9eef8c1928b68320a2fa94240f969f6fec08c"},
@@ -222,6 +227,7 @@ description = "PEP 224 implementation"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "attributes-doc-0.4.0.tar.gz", hash = "sha256:b1576c94a714e9fc2c65c47cf10d0c8e1a5f7c4f5ae7f69006be108d95cbfbfb"},
     {file = "attributes_doc-0.4.0-py2.py3-none-any.whl", hash = "sha256:4c3007d9e58f3a6cb4b9c614c4d4ce2d92161581f28e594ddd8241cc3a113bdd"},
@@ -234,18 +240,19 @@ description = "Classes Without Boilerplate"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "attrs-24.3.0-py3-none-any.whl", hash = "sha256:ac96cd038792094f438ad1f6ff80837353805ac950cd2aa0e0625ef19850c308"},
     {file = "attrs-24.3.0.tar.gz", hash = "sha256:8f5c07333d543103541ba7be0e2ce16eeee8130cb0b3f9238ab904ce1e85baff"},
 ]
 
 [package.extras]
-benchmark = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pympler", "pytest (>=4.3.0)", "pytest-codspeed", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"]
-cov = ["cloudpickle ; platform_python_implementation == \"CPython\"", "coverage[toml] (>=5.3)", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"]
-dev = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pre-commit-uv", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"]
+benchmark = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-codspeed", "pytest-mypy-plugins", "pytest-xdist[psutil]"]
+cov = ["cloudpickle", "coverage[toml] (>=5.3)", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"]
+dev = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pre-commit-uv", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"]
 docs = ["cogapp", "furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier (<24.7)"]
-tests = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"]
-tests-mypy = ["mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\""]
+tests = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"]
+tests-mypy = ["mypy (>=1.11.1)", "pytest-mypy-plugins"]
 
 [[package]]
 name = "avro"
@@ -254,7 +261,7 @@ description = "Avro is a serialization and RPC framework."
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "avro-1.12.0-py2.py3-none-any.whl", hash = "sha256:9a255c72e1837341dd4f6ff57b2b6f68c0f0cecdef62dd04962e10fd33bec05b"},
     {file = "avro-1.12.0.tar.gz", hash = "sha256:cad9c53b23ceed699c7af6bddced42e2c572fd6b408c257a7d4fc4e8cf2e2d6b"},
@@ -271,6 +278,7 @@ description = "Function decoration for backoff and retry"
 optional = false
 python-versions = ">=3.7,<4.0"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "backoff-2.2.1-py3-none-any.whl", hash = "sha256:63579f9a0628e06278f7e47b7d7d5b6ce20dc65c5e96a6f3ca99a6adca0396e8"},
     {file = "backoff-2.2.1.tar.gz", hash = "sha256:03f829f5bb1923180821643f8753b0502c3b682293992485b0eef2807afa5cba"},
@@ -283,7 +291,7 @@ description = "Screen-scraping library"
 optional = true
 python-versions = ">=3.6.0"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"},
     {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"},
@@ -306,6 +314,7 @@ description = "When they're not builtins, they're boltons."
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "boltons-25.0.0-py3-none-any.whl", hash = "sha256:dc9fb38bf28985715497d1b54d00b62ea866eca3938938ea9043e254a3a6ca62"},
     {file = "boltons-25.0.0.tar.gz", hash = "sha256:e110fbdc30b7b9868cb604e3f71d4722dd8f4dcb4a5ddd06028ba8f1ab0b5ace"},
@@ -318,6 +327,7 @@ description = "Bash style brace expander."
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "bracex-2.5.post1-py3-none-any.whl", hash = "sha256:13e5732fec27828d6af308628285ad358047cec36801598368cb28bc631dbaf6"},
     {file = "bracex-2.5.post1.tar.gz", hash = "sha256:12c50952415bfa773d2d9ccb8e79651b8cdb1f31a42f6091b804f6ba2b4a66b6"},
@@ -330,6 +340,7 @@ description = "Extensible memoizing collections and decorators"
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "cachetools-5.5.1-py3-none-any.whl", hash = "sha256:b76651fdc3b24ead3c648bbdeeb940c1b04d365b38b4af66788f9ec4a81d42bb"},
     {file = "cachetools-5.5.1.tar.gz", hash = "sha256:70f238fbba50383ef62e55c6aff6d9673175fe59f7c6782c7a0b9e38f4a9df95"},
@@ -342,6 +353,7 @@ description = "Composable complex class support for attrs and dataclasses."
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "cattrs-24.1.2-py3-none-any.whl", hash = "sha256:67c7495b760168d931a10233f979b28dc04daf853b30752246f4f8471c6d68d0"},
     {file = "cattrs-24.1.2.tar.gz", hash = "sha256:8028cfe1ff5382df59dd36474a86e02d817b06eaf8af84555441bac915d2ef85"},
@@ -356,8 +368,8 @@ typing-extensions = {version = ">=4.1.0,<4.6.3 || >4.6.3", markers = "python_ver
 bson = ["pymongo (>=4.4.0)"]
 cbor2 = ["cbor2 (>=5.4.6)"]
 msgpack = ["msgpack (>=1.0.5)"]
-msgspec = ["msgspec (>=0.18.5) ; implementation_name == \"cpython\""]
-orjson = ["orjson (>=3.9.2) ; implementation_name == \"cpython\""]
+msgspec = ["msgspec (>=0.18.5)"]
+orjson = ["orjson (>=3.9.2)"]
 pyyaml = ["pyyaml (>=6.0)"]
 tomlkit = ["tomlkit (>=0.11.8)"]
 ujson = ["ujson (>=5.7.0)"]
@@ -369,6 +381,7 @@ description = "Python package for providing Mozilla's CA Bundle."
 optional = false
 python-versions = ">=3.6"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56"},
     {file = "certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db"},
@@ -381,7 +394,7 @@ description = "Foreign Function Interface for Python calling C code."
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "platform_python_implementation != \"PyPy\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and platform_python_implementation != \"PyPy\""
 files = [
     {file = "cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14"},
     {file = "cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67"},
@@ -462,7 +475,7 @@ description = "Universal encoding detector for Python 3"
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970"},
     {file = "chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7"},
@@ -475,6 +488,7 @@ description = "The Real First Universal Charset Detector. Open, modern and activ
 optional = false
 python-versions = ">=3.7"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de"},
     {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176"},
@@ -577,6 +591,7 @@ description = "Composable command line interface toolkit"
 optional = false
 python-versions = ">=3.7"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2"},
     {file = "click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a"},
@@ -592,7 +607,7 @@ description = ""
 optional = true
 python-versions = ">=3.7,<4.0"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "cohere-4.21-py3-none-any.whl", hash = "sha256:5eb81db62e78b3156e734421cc3e657054f9d9f1d68b9f38cf48fe3a8ae40dbc"},
     {file = "cohere-4.21.tar.gz", hash = "sha256:f611438f409dfc5d5a0a153a585349f5a80b169c7102b5994d9999ecf8440866"},
@@ -613,7 +628,7 @@ description = "Cross-platform colored terminal text."
 optional = false
 python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
 groups = ["main", "dev"]
-markers = "platform_system == \"Windows\" or sys_platform == \"win32\""
+markers = "(platform_system == \"Windows\" or sys_platform == \"win32\") and (python_version <= \"3.11\" or python_version >= \"3.12\")"
 files = [
     {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
     {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
@@ -626,7 +641,7 @@ description = "Python library for calculating contours of 2D quadrilateral grids
 optional = true
 python-versions = ">=3.10"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "contourpy-1.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a045f341a77b77e1c5de31e74e966537bba9f3c4099b35bf4c2e3939dd54cdab"},
     {file = "contourpy-1.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:500360b77259914f7805af7462e41f9cb7ca92ad38e9f94d6c8641b089338124"},
@@ -701,6 +716,7 @@ description = "Code coverage measurement for Python"
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "coverage-7.6.10-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5c912978f7fbf47ef99cec50c4401340436d200d41d714c7a4766f377c5b7b78"},
     {file = "coverage-7.6.10-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a01ec4af7dfeb96ff0078ad9a48810bb0cc8abcb0115180c6013a6b26237626c"},
@@ -770,7 +786,7 @@ files = [
 tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.11.0a6\" and extra == \"toml\""}
 
 [package.extras]
-toml = ["tomli ; python_full_version <= \"3.11.0a6\""]
+toml = ["tomli"]
 
 [[package]]
 name = "cramjam"
@@ -779,7 +795,7 @@ description = "Thin Python bindings to de/compression algorithms in Rust"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "cramjam-2.9.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:8e82464d1e00fbbb12958999b8471ba5e9f3d9711954505a0a7b378762332e6f"},
     {file = "cramjam-2.9.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6d2df8a6511cc08ef1fccd2e0c65e2ebc9f57574ec8376052a76851af5398810"},
@@ -883,6 +899,7 @@ description = "cryptography is a package which provides cryptographic recipes an
 optional = false
 python-versions = "!=3.9.0,!=3.9.1,>=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "cryptography-44.0.2-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:efcfe97d1b3c79e486554efddeb8f6f53a4cdd4cf6086642784fa31fc384e1d7"},
     {file = "cryptography-44.0.2-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29ecec49f3ba3f3849362854b7253a9f59799e3763b0c9d0826259a88efa02f1"},
@@ -925,10 +942,10 @@ files = [
 cffi = {version = ">=1.12", markers = "platform_python_implementation != \"PyPy\""}
 
 [package.extras]
-docs = ["sphinx (>=5.3.0)", "sphinx-rtd-theme (>=3.0.0) ; python_version >= \"3.8\""]
+docs = ["sphinx (>=5.3.0)", "sphinx-rtd-theme (>=3.0.0)"]
 docstest = ["pyenchant (>=3)", "readme-renderer (>=30.0)", "sphinxcontrib-spelling (>=7.3.1)"]
-nox = ["nox (>=2024.4.15)", "nox[uv] (>=2024.3.2) ; python_version >= \"3.8\""]
-pep8test = ["check-sdist ; python_version >= \"3.8\"", "click (>=8.0.1)", "mypy (>=1.4)", "ruff (>=0.3.6)"]
+nox = ["nox (>=2024.4.15)", "nox[uv] (>=2024.3.2)"]
+pep8test = ["check-sdist", "click (>=8.0.1)", "mypy (>=1.4)", "ruff (>=0.3.6)"]
 sdist = ["build (>=1.0.0)"]
 ssh = ["bcrypt (>=3.1.5)"]
 test = ["certifi (>=2024)", "cryptography-vectors (==44.0.2)", "pretend (>=0.7)", "pytest (>=7.4.0)", "pytest-benchmark (>=4.0)", "pytest-cov (>=2.10.1)", "pytest-xdist (>=3.5.0)"]
@@ -941,7 +958,7 @@ description = "Composable style cycles"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"},
     {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"},
@@ -958,7 +975,7 @@ description = "Easily serialize dataclasses to and from JSON."
 optional = true
 python-versions = "<4.0,>=3.7"
 groups = ["main"]
-markers = "extra == \"vector-db-based\" or extra == \"file-based\""
+markers = "(extra == \"vector-db-based\" or extra == \"file-based\") and (python_version <= \"3.11\" or python_version >= \"3.12\")"
 files = [
     {file = "dataclasses_json-0.6.7-py3-none-any.whl", hash = "sha256:0dbf33f26c8d5305befd61b39d2b3414e8a407bedc2834dea9b8d642666fb40a"},
     {file = "dataclasses_json-0.6.7.tar.gz", hash = "sha256:b6b3e528266ea45b9535223bc53ca645f5208833c29229e847b3f26a1cc55fc0"},
@@ -975,6 +992,7 @@ description = "A command line utility to check for unused, missing and transitiv
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "deptry-0.23.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:1f2a6817a37d76e8f6b667381b7caf6ea3e6d6c18b5be24d36c625f387c79852"},
     {file = "deptry-0.23.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:9601b64cc0aed42687fdd5c912d5f1e90d7f7333fb589b14e35bfdfebae866f3"},
@@ -1008,6 +1026,7 @@ description = "Filesystem-like pathing and searching for dictionaries"
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "dpath-2.2.0-py3-none-any.whl", hash = "sha256:b330a375ded0a0d2ed404440f6c6a715deae5313af40bbb01c8a41d891900576"},
     {file = "dpath-2.2.0.tar.gz", hash = "sha256:34f7e630dc55ea3f219e555726f5da4b4b25f2200319c8e6902c394258dd6a3e"},
@@ -1020,6 +1039,7 @@ description = "Dynamic version generation"
 optional = false
 python-versions = ">=3.5"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "dunamai-1.23.0-py3-none-any.whl", hash = "sha256:a0906d876e92441793c6a423e16a4802752e723e9c9a5aabdc5535df02dbe041"},
     {file = "dunamai-1.23.0.tar.gz", hash = "sha256:a163746de7ea5acb6dacdab3a6ad621ebc612ed1e528aaa8beedb8887fccd2c4"},
@@ -1035,7 +1055,7 @@ description = "Emoji for Python"
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "emoji-2.14.1-py3-none-any.whl", hash = "sha256:35a8a486c1460addb1499e3bf7929d3889b2e2841a57401903699fef595e942b"},
     {file = "emoji-2.14.1.tar.gz", hash = "sha256:f8c50043d79a2c1410ebfae833ae1868d5941a67a6cd4d18377e2eb0bd79346b"},
@@ -1051,7 +1071,7 @@ description = "An implementation of lxml.xmlfile for the standard library"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa"},
     {file = "et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54"},
@@ -1064,7 +1084,7 @@ description = "Backport of PEP 654 (exception groups)"
 optional = false
 python-versions = ">=3.7"
 groups = ["main", "dev"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 files = [
     {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"},
     {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"},
@@ -1080,7 +1100,7 @@ description = "Fast read/write of AVRO files"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"vector-db-based\" or extra == \"file-based\""
+markers = "(extra == \"vector-db-based\" or extra == \"file-based\") and (python_version <= \"3.11\" or python_version >= \"3.12\")"
 files = [
     {file = "fastavro-1.8.2-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:0e08964b2e9a455d831f2557402a683d4c4d45206f2ab9ade7c69d3dc14e0e58"},
     {file = "fastavro-1.8.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:401a70b1e5c7161420c6019e0c8afa88f7c8a373468591f5ec37639a903c2509"},
@@ -1122,7 +1142,7 @@ description = "Infer file type and MIME type of any file/buffer. No external dep
 optional = true
 python-versions = "*"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "filetype-1.2.0-py2.py3-none-any.whl", hash = "sha256:7ce71b6880181241cf7ac8697a2f1eb6a8bd9b429f7ad6d27b8db9ba5f1c2d25"},
     {file = "filetype-1.2.0.tar.gz", hash = "sha256:66b56cd6474bf41d8c54660347d37afcc3f7d1970648de365c102ef77548aadb"},
@@ -1135,6 +1155,7 @@ description = "the modular source code checker: pep8 pyflakes and co"
 optional = false
 python-versions = ">=3.8.1"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "flake8-6.1.0-py2.py3-none-any.whl", hash = "sha256:ffdfce58ea94c6580c77888a86506937f9a1a227dfcd15f245d694ae20a6b6e5"},
     {file = "flake8-6.1.0.tar.gz", hash = "sha256:d5b3857f07c030bdb5bf41c7f53799571d75c4491748a3adcd47de929e34cd23"},
@@ -1152,7 +1173,7 @@ description = "Tools to manipulate font files"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "fonttools-4.55.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3b332ea7b7f5f3d99f9bc5a28a23c3824ae72711abf7c4e1d62fa21699fdebe7"},
     {file = "fonttools-4.55.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5d8f925909256e62152e7c3e192655dbca3ab8c3cdef7d7b436732727e80feb6"},
@@ -1207,18 +1228,18 @@ files = [
 ]
 
 [package.extras]
-all = ["brotli (>=1.0.1) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=0.8.0) ; platform_python_implementation != \"CPython\"", "fs (>=2.2.0,<3)", "lxml (>=4.0)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres ; platform_python_implementation == \"PyPy\"", "pycairo", "scipy ; platform_python_implementation != \"PyPy\"", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.1.0) ; python_version <= \"3.12\"", "xattr ; sys_platform == \"darwin\"", "zopfli (>=0.1.4)"]
+all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "pycairo", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.1.0)", "xattr", "zopfli (>=0.1.4)"]
 graphite = ["lz4 (>=1.7.4.2)"]
-interpolatable = ["munkres ; platform_python_implementation == \"PyPy\"", "pycairo", "scipy ; platform_python_implementation != \"PyPy\""]
+interpolatable = ["munkres", "pycairo", "scipy"]
 lxml = ["lxml (>=4.0)"]
 pathops = ["skia-pathops (>=0.5.0)"]
 plot = ["matplotlib"]
 repacker = ["uharfbuzz (>=0.23.0)"]
 symfont = ["sympy"]
-type1 = ["xattr ; sys_platform == \"darwin\""]
+type1 = ["xattr"]
 ufo = ["fs (>=2.2.0,<3)"]
-unicode = ["unicodedata2 (>=15.1.0) ; python_version <= \"3.12\""]
-woff = ["brotli (>=1.0.1) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=0.8.0) ; platform_python_implementation != \"CPython\"", "zopfli (>=0.1.4)"]
+unicode = ["unicodedata2 (>=15.1.0)"]
+woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"]
 
 [[package]]
 name = "freezegun"
@@ -1227,6 +1248,7 @@ description = "Let your Python tests travel through time"
 optional = false
 python-versions = ">=3.7"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "freezegun-1.5.1-py3-none-any.whl", hash = "sha256:bf111d7138a8abe55ab48a71755673dbaa4ab87f4cff5634a4442dfec34c15f1"},
     {file = "freezegun-1.5.1.tar.gz", hash = "sha256:b29dedfcda6d5e8e083ce71b2b542753ad48cfec44037b3fc79702e2980a89e9"},
@@ -1242,7 +1264,7 @@ description = "A list-like structure which implements collections.abc.MutableSeq
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "frozenlist-1.5.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:5b6a66c18b5b9dd261ca98dffcb826a525334b2f29e7caa54e182255c5f6a65a"},
     {file = "frozenlist-1.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d1b3eb7b05ea246510b43a7e53ed1653e55c2121019a97e60cad7efb881a97bb"},
@@ -1345,6 +1367,7 @@ description = "GenSON is a powerful, user-friendly JSON Schema generator."
 optional = false
 python-versions = "*"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "genson-1.3.0-py3-none-any.whl", hash = "sha256:468feccd00274cc7e4c09e84b08704270ba8d95232aa280f65b986139cec67f7"},
     {file = "genson-1.3.0.tar.gz", hash = "sha256:e02db9ac2e3fd29e65b5286f7135762e2cd8a986537c075b06fc5f1517308e37"},
@@ -1357,6 +1380,7 @@ description = "Google API client core library"
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "google_api_core-2.24.2-py3-none-any.whl", hash = "sha256:810a63ac95f3c441b7c0e43d344e372887f62ce9071ba972eacf32672e072de9"},
     {file = "google_api_core-2.24.2.tar.gz", hash = "sha256:81718493daf06d96d6bc76a91c23874dbf2fac0adbbf542831b805ee6e974696"},
@@ -1366,12 +1390,12 @@ files = [
 google-auth = ">=2.14.1,<3.0.0"
 googleapis-common-protos = ">=1.56.2,<2.0.0"
 grpcio = [
-    {version = ">=1.49.1,<2.0dev", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""},
     {version = ">=1.33.2,<2.0dev", optional = true, markers = "python_version < \"3.11\" and extra == \"grpc\""},
+    {version = ">=1.49.1,<2.0dev", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""},
 ]
 grpcio-status = [
+    {version = ">=1.33.2,<2.0.dev0", optional = true, markers = "python_version < \"3.11\" and extra == \"grpc\""},
     {version = ">=1.49.1,<2.0.dev0", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""},
-    {version = ">=1.33.2,<2.0.dev0", optional = true, markers = "extra == \"grpc\""},
 ]
 proto-plus = ">=1.22.3,<2.0.0"
 protobuf = ">=3.19.5,<3.20.0 || >3.20.0,<3.20.1 || >3.20.1,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<7.0.0"
@@ -1379,7 +1403,7 @@ requests = ">=2.18.0,<3.0.0"
 
 [package.extras]
 async-rest = ["google-auth[aiohttp] (>=2.35.0,<3.0.dev0)"]
-grpc = ["grpcio (>=1.33.2,<2.0dev)", "grpcio (>=1.49.1,<2.0dev) ; python_version >= \"3.11\"", "grpcio-status (>=1.33.2,<2.0.dev0)", "grpcio-status (>=1.49.1,<2.0.dev0) ; python_version >= \"3.11\""]
+grpc = ["grpcio (>=1.33.2,<2.0dev)", "grpcio (>=1.49.1,<2.0dev)", "grpcio-status (>=1.33.2,<2.0.dev0)", "grpcio-status (>=1.49.1,<2.0.dev0)"]
 grpcgcp = ["grpcio-gcp (>=0.2.2,<1.0.dev0)"]
 grpcio-gcp = ["grpcio-gcp (>=0.2.2,<1.0.dev0)"]
 
@@ -1390,6 +1414,7 @@ description = "Google Authentication Library"
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "google_auth-2.39.0-py2.py3-none-any.whl", hash = "sha256:0150b6711e97fb9f52fe599f55648950cc4540015565d8fbb31be2ad6e1548a2"},
     {file = "google_auth-2.39.0.tar.gz", hash = "sha256:73222d43cdc35a3aeacbfdcaf73142a97839f10de930550d89ebfe1d0a00cde7"},
@@ -1403,11 +1428,11 @@ rsa = ">=3.1.4,<5"
 [package.extras]
 aiohttp = ["aiohttp (>=3.6.2,<4.0.0)", "requests (>=2.20.0,<3.0.0)"]
 enterprise-cert = ["cryptography", "pyopenssl"]
-pyjwt = ["cryptography (<39.0.0) ; python_version < \"3.8\"", "cryptography (>=38.0.3)", "pyjwt (>=2.0)"]
-pyopenssl = ["cryptography (<39.0.0) ; python_version < \"3.8\"", "cryptography (>=38.0.3)", "pyopenssl (>=20.0.0)"]
+pyjwt = ["cryptography (<39.0.0)", "cryptography (>=38.0.3)", "pyjwt (>=2.0)"]
+pyopenssl = ["cryptography (<39.0.0)", "cryptography (>=38.0.3)", "pyopenssl (>=20.0.0)"]
 reauth = ["pyu2f (>=0.1.5)"]
 requests = ["requests (>=2.20.0,<3.0.0)"]
-testing = ["aiohttp (<3.10.0)", "aiohttp (>=3.6.2,<4.0.0)", "aioresponses", "cryptography (<39.0.0) ; python_version < \"3.8\"", "cryptography (>=38.0.3)", "flask", "freezegun", "grpcio", "mock", "oauth2client", "packaging", "pyjwt (>=2.0)", "pyopenssl (<24.3.0)", "pyopenssl (>=20.0.0)", "pytest", "pytest-asyncio", "pytest-cov", "pytest-localserver", "pyu2f (>=0.1.5)", "requests (>=2.20.0,<3.0.0)", "responses", "urllib3"]
+testing = ["aiohttp (<3.10.0)", "aiohttp (>=3.6.2,<4.0.0)", "aioresponses", "cryptography (<39.0.0)", "cryptography (>=38.0.3)", "flask", "freezegun", "grpcio", "mock", "oauth2client", "packaging", "pyjwt (>=2.0)", "pyopenssl (<24.3.0)", "pyopenssl (>=20.0.0)", "pytest", "pytest-asyncio", "pytest-cov", "pytest-localserver", "pyu2f (>=0.1.5)", "requests (>=2.20.0,<3.0.0)", "responses", "urllib3"]
 urllib3 = ["packaging", "urllib3"]
 
 [[package]]
@@ -1417,6 +1442,7 @@ description = "Google Cloud Secret Manager API client library"
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "google_cloud_secret_manager-2.23.3-py3-none-any.whl", hash = "sha256:fe06ebb2f71eb739ecc6c14ea9e8dafcb9bbc6123b78b2f8986ece6733d23a1a"},
     {file = "google_cloud_secret_manager-2.23.3.tar.gz", hash = "sha256:598c4c0a9d10d49d500eb4aea3255dff250aa2f92c028f5c97e3b367f768c808"},
@@ -1436,6 +1462,7 @@ description = "Common protobufs used in Google APIs"
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "googleapis_common_protos-1.70.0-py3-none-any.whl", hash = "sha256:b8bfcca8c25a2bb253e0e0b0adaf8c00773e5e6af6fd92397576680b807e0fd8"},
     {file = "googleapis_common_protos-1.70.0.tar.gz", hash = "sha256:0e1b44e0ea153e6594f9f394fef15193a68aaaea2d843f83e2742717ca753257"},
@@ -1455,7 +1482,7 @@ description = "Lightweight in-process concurrent programming"
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
-markers = "(extra == \"vector-db-based\" or extra == \"sql\") and (platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\")"
+markers = "(extra == \"vector-db-based\" or extra == \"sql\") and (platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\") and (python_version <= \"3.11\" or python_version >= \"3.12\")"
 files = [
     {file = "greenlet-3.1.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:0bbae94a29c9e5c7e4a2b7f0aae5c17e8e90acbfd3bf6270eeba60c39fce3563"},
     {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fde093fb93f35ca72a556cf72c92ea3ebfda3d79fc35bb19fbe685853869a83"},
@@ -1543,6 +1570,7 @@ description = "IAM API client library"
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "grpc_google_iam_v1-0.14.2-py3-none-any.whl", hash = "sha256:a3171468459770907926d56a440b2bb643eec1d7ba215f48f3ecece42b4d8351"},
     {file = "grpc_google_iam_v1-0.14.2.tar.gz", hash = "sha256:b3e1fc387a1a329e41672197d0ace9de22c78dd7d215048c4c78712073f7bd20"},
@@ -1560,6 +1588,7 @@ description = "HTTP/2-based RPC framework"
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "grpcio-1.71.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:c200cb6f2393468142eb50ab19613229dcc7829b5ccee8b658a36005f6669fdd"},
     {file = "grpcio-1.71.0-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:b2266862c5ad664a380fbbcdbdb8289d71464c42a8c29053820ee78ba0119e5d"},
@@ -1624,6 +1653,7 @@ description = "Status proto mapping for gRPC"
 optional = false
 python-versions = ">=3.6"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "grpcio-status-1.62.3.tar.gz", hash = "sha256:289bdd7b2459794a12cf95dc0cb727bd4a1742c37bd823f760236c937e53a485"},
     {file = "grpcio_status-1.62.3-py3-none-any.whl", hash = "sha256:f9049b762ba8de6b1086789d8315846e094edac2c50beaf462338b301a8fd4b8"},
@@ -1641,6 +1671,7 @@ description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1"
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"},
     {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"},
@@ -1653,6 +1684,7 @@ description = "A minimal low-level HTTP client."
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "httpcore-1.0.7-py3-none-any.whl", hash = "sha256:a3fff8f43dc260d5bd363d9f9cf1830fa3a458b332856f34282de498ed420edd"},
     {file = "httpcore-1.0.7.tar.gz", hash = "sha256:8551cb62a169ec7162ac7be8d4817d561f60e08eaa485234898414bb5a8a0b4c"},
@@ -1675,6 +1707,7 @@ description = "The next generation HTTP client."
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad"},
     {file = "httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc"},
@@ -1687,7 +1720,7 @@ httpcore = "==1.*"
 idna = "*"
 
 [package.extras]
-brotli = ["brotli ; platform_python_implementation == \"CPython\"", "brotlicffi ; platform_python_implementation != \"CPython\""]
+brotli = ["brotli", "brotlicffi"]
 cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"]
 http2 = ["h2 (>=3,<5)"]
 socks = ["socksio (==1.*)"]
@@ -1700,6 +1733,7 @@ description = "Internationalized Domain Names in Applications (IDNA)"
 optional = false
 python-versions = ">=3.6"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"},
     {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"},
@@ -1715,7 +1749,7 @@ description = "Read metadata from Python packages"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "importlib_metadata-6.11.0-py3-none-any.whl", hash = "sha256:f0afba6205ad8f8947c7d338b5342d5db2afbfd82f9cbef7879a9539cc12eb9b"},
     {file = "importlib_metadata-6.11.0.tar.gz", hash = "sha256:1231cf92d825c9e03cfc4da076a16de6422c863558229ea0b22b675657463443"},
@@ -1727,7 +1761,7 @@ zipp = ">=0.5"
 [package.extras]
 docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
 perf = ["ipython"]
-testing = ["flufl.flake8", "importlib-resources (>=1.3) ; python_version < \"3.9\"", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7) ; platform_python_implementation != \"PyPy\"", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1) ; platform_python_implementation != \"PyPy\"", "pytest-perf (>=0.9.2)", "pytest-ruff"]
+testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-perf (>=0.9.2)", "pytest-ruff"]
 
 [[package]]
 name = "iniconfig"
@@ -1736,6 +1770,7 @@ description = "brain-dead simple config-ini parsing"
 optional = false
 python-versions = ">=3.7"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"},
     {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},
@@ -1748,6 +1783,7 @@ description = "An ISO 8601 date/time/duration parser and formatter"
 optional = false
 python-versions = "*"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "isodate-0.6.1-py2.py3-none-any.whl", hash = "sha256:0751eece944162659049d35f4f549ed815792b38793f07cf73381c1c87cbed96"},
     {file = "isodate-0.6.1.tar.gz", hash = "sha256:48c5881de7e8b0a0d648cb024c8062dc84e7b840ed81e864c7614fd3c127bde9"},
@@ -1763,6 +1799,7 @@ description = "A very fast and expressive template engine."
 optional = false
 python-versions = ">=3.7"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb"},
     {file = "jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb"},
@@ -1781,6 +1818,7 @@ description = "Lightweight pipelining with Python functions"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "joblib-1.4.2-py3-none-any.whl", hash = "sha256:06d478d5674cbc267e7496a410ee875abd68e4340feff4490bcb7afb88060ae6"},
     {file = "joblib-1.4.2.tar.gz", hash = "sha256:2382c5816b2636fbd20a09e0f4e9dad4736765fdfb7dca582943b9c1366b3f0e"},
@@ -1793,6 +1831,7 @@ description = "Apply JSON-Patches (RFC 6902)"
 optional = true
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "jsonpatch-1.33-py2.py3-none-any.whl", hash = "sha256:0ae28c0cd062bbd8b8ecc26d7d164fbbea9652a1a3693f3b956c1eae5145dade"},
     {file = "jsonpatch-1.33.tar.gz", hash = "sha256:9fcd4009c41e6d12348b4a0ff2563ba56a2923a7dfee731d004e212e1ee5030c"},
@@ -1808,6 +1847,7 @@ description = "Identify specific nodes in a JSON document (RFC 6901)"
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942"},
     {file = "jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef"},
@@ -1820,6 +1860,7 @@ description = "An implementation of JSON Reference for Python"
 optional = false
 python-versions = "*"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "jsonref-0.2-py3-none-any.whl", hash = "sha256:b1e82fa0b62e2c2796a13e5401fe51790b248f6d9bf9d7212a3e31a3501b291f"},
     {file = "jsonref-0.2.tar.gz", hash = "sha256:f3c45b121cf6257eafabdc3a8008763aed1cd7da06dbabc59a9e4d2a5e4e6697"},
@@ -1832,6 +1873,7 @@ description = "An implementation of JSON Schema validation for Python"
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "jsonschema-4.17.3-py3-none-any.whl", hash = "sha256:a870ad254da1a8ca84b6a2905cac29d265f805acc57af304784962a2aa6508f6"},
     {file = "jsonschema-4.17.3.tar.gz", hash = "sha256:0f864437ab8b6076ba6707453ef8f98a6a0d512a80e93f8abdb676f737ecb60d"},
@@ -1852,7 +1894,7 @@ description = "A fast implementation of the Cassowary constraint solver"
 optional = true
 python-versions = ">=3.10"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "kiwisolver-1.4.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88c6f252f6816a73b1f8c904f7bbe02fd67c09a69f7cb8a0eecdbf5ce78e63db"},
     {file = "kiwisolver-1.4.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c72941acb7b67138f35b879bbe85be0f6c6a70cab78fe3ef6db9c024d9223e5b"},
@@ -1943,7 +1985,7 @@ description = "Building applications with LLMs through composability"
 optional = true
 python-versions = "<4.0,>=3.8.1"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "langchain-0.1.16-py3-none-any.whl", hash = "sha256:bc074cc5e51fad79b9ead1572fc3161918d0f614a6c8f0460543d505ad249ac7"},
     {file = "langchain-0.1.16.tar.gz", hash = "sha256:b6bce78f8c071baa898884accfff15c3d81da2f0dd86c20e2f4c80b41463f49f"},
@@ -1972,11 +2014,11 @@ cli = ["typer (>=0.9.0,<0.10.0)"]
 cohere = ["cohere (>=4,<6)"]
 docarray = ["docarray[hnswlib] (>=0.32.0,<0.33.0)"]
 embeddings = ["sentence-transformers (>=2,<3)"]
-extended-testing = ["aiosqlite (>=0.19.0,<0.20.0)", "aleph-alpha-client (>=2.15.0,<3.0.0)", "anthropic (>=0.3.11,<0.4.0)", "arxiv (>=1.4,<2.0)", "assemblyai (>=0.17.0,<0.18.0)", "atlassian-python-api (>=3.36.0,<4.0.0)", "beautifulsoup4 (>=4,<5)", "bibtexparser (>=1.4.0,<2.0.0)", "cassio (>=0.1.0,<0.2.0)", "chardet (>=5.1.0,<6.0.0)", "cohere (>=4,<6)", "couchbase (>=4.1.9,<5.0.0)", "dashvector (>=1.0.1,<2.0.0)", "databricks-vectorsearch (>=0.21,<0.22)", "datasets (>=2.15.0,<3.0.0)", "dgml-utils (>=0.3.0,<0.4.0)", "esprima (>=4.0.1,<5.0.0)", "faiss-cpu (>=1,<2)", "feedparser (>=6.0.10,<7.0.0)", "fireworks-ai (>=0.9.0,<0.10.0)", "geopandas (>=0.13.1,<0.14.0)", "gitpython (>=3.1.32,<4.0.0)", "google-cloud-documentai (>=2.20.1,<3.0.0)", "gql (>=3.4.1,<4.0.0)", "hologres-vector (>=0.0.6,<0.0.7)", "html2text (>=2020.1.16,<2021.0.0)", "javelin-sdk (>=0.1.8,<0.2.0)", "jinja2 (>=3,<4)", "jq (>=1.4.1,<2.0.0)", "jsonschema (>1)", "langchain-openai (>=0.0.2,<0.1)", "lxml (>=4.9.3,<6.0)", "markdownify (>=0.11.6,<0.12.0)", "motor (>=3.3.1,<4.0.0)", "msal (>=1.25.0,<2.0.0)", "mwparserfromhell (>=0.6.4,<0.7.0)", "mwxml (>=0.3.3,<0.4.0)", "newspaper3k (>=0.2.8,<0.3.0)", "numexpr (>=2.8.6,<3.0.0)", "openai (<2)", "openapi-pydantic (>=0.3.2,<0.4.0)", "pandas (>=2.0.1,<3.0.0)", "pdfminer-six (>=20221105,<20221106)", "pgvector (>=0.1.6,<0.2.0)", "praw (>=7.7.1,<8.0.0)", "psychicapi (>=0.8.0,<0.9.0)", "py-trello (>=0.19.0,<0.20.0)", "pymupdf (>=1.22.3,<2.0.0)", "pypdf (>=3.4.0,<4.0.0)", "pypdfium2 (>=4.10.0,<5.0.0)", "pyspark (>=3.4.0,<4.0.0)", "rank-bm25 (>=0.2.2,<0.3.0)", "rapidfuzz (>=3.1.1,<4.0.0)", "rapidocr-onnxruntime (>=1.3.2,<2.0.0) ; python_full_version >= \"3.8.1\" and python_version < \"3.12\"", "rdflib (==7.0.0)", "requests-toolbelt (>=1.0.0,<2.0.0)", "rspace_client (>=2.5.0,<3.0.0)", "scikit-learn (>=1.2.2,<2.0.0)", "sqlite-vss (>=0.1.2,<0.2.0)", "streamlit (>=1.18.0,<2.0.0) ; python_full_version >= \"3.8.1\" and python_full_version != \"3.9.7\" and python_version < \"4.0\"", "sympy (>=1.12,<2.0)", "telethon (>=1.28.5,<2.0.0)", "timescale-vector (>=0.0.1,<0.0.2)", "tqdm (>=4.48.0)", "upstash-redis (>=0.15.0,<0.16.0)", "xata (>=1.0.0a7,<2.0.0)", "xmltodict (>=0.13.0,<0.14.0)"]
+extended-testing = ["aiosqlite (>=0.19.0,<0.20.0)", "aleph-alpha-client (>=2.15.0,<3.0.0)", "anthropic (>=0.3.11,<0.4.0)", "arxiv (>=1.4,<2.0)", "assemblyai (>=0.17.0,<0.18.0)", "atlassian-python-api (>=3.36.0,<4.0.0)", "beautifulsoup4 (>=4,<5)", "bibtexparser (>=1.4.0,<2.0.0)", "cassio (>=0.1.0,<0.2.0)", "chardet (>=5.1.0,<6.0.0)", "cohere (>=4,<6)", "couchbase (>=4.1.9,<5.0.0)", "dashvector (>=1.0.1,<2.0.0)", "databricks-vectorsearch (>=0.21,<0.22)", "datasets (>=2.15.0,<3.0.0)", "dgml-utils (>=0.3.0,<0.4.0)", "esprima (>=4.0.1,<5.0.0)", "faiss-cpu (>=1,<2)", "feedparser (>=6.0.10,<7.0.0)", "fireworks-ai (>=0.9.0,<0.10.0)", "geopandas (>=0.13.1,<0.14.0)", "gitpython (>=3.1.32,<4.0.0)", "google-cloud-documentai (>=2.20.1,<3.0.0)", "gql (>=3.4.1,<4.0.0)", "hologres-vector (>=0.0.6,<0.0.7)", "html2text (>=2020.1.16,<2021.0.0)", "javelin-sdk (>=0.1.8,<0.2.0)", "jinja2 (>=3,<4)", "jq (>=1.4.1,<2.0.0)", "jsonschema (>1)", "langchain-openai (>=0.0.2,<0.1)", "lxml (>=4.9.3,<6.0)", "markdownify (>=0.11.6,<0.12.0)", "motor (>=3.3.1,<4.0.0)", "msal (>=1.25.0,<2.0.0)", "mwparserfromhell (>=0.6.4,<0.7.0)", "mwxml (>=0.3.3,<0.4.0)", "newspaper3k (>=0.2.8,<0.3.0)", "numexpr (>=2.8.6,<3.0.0)", "openai (<2)", "openapi-pydantic (>=0.3.2,<0.4.0)", "pandas (>=2.0.1,<3.0.0)", "pdfminer-six (>=20221105,<20221106)", "pgvector (>=0.1.6,<0.2.0)", "praw (>=7.7.1,<8.0.0)", "psychicapi (>=0.8.0,<0.9.0)", "py-trello (>=0.19.0,<0.20.0)", "pymupdf (>=1.22.3,<2.0.0)", "pypdf (>=3.4.0,<4.0.0)", "pypdfium2 (>=4.10.0,<5.0.0)", "pyspark (>=3.4.0,<4.0.0)", "rank-bm25 (>=0.2.2,<0.3.0)", "rapidfuzz (>=3.1.1,<4.0.0)", "rapidocr-onnxruntime (>=1.3.2,<2.0.0)", "rdflib (==7.0.0)", "requests-toolbelt (>=1.0.0,<2.0.0)", "rspace_client (>=2.5.0,<3.0.0)", "scikit-learn (>=1.2.2,<2.0.0)", "sqlite-vss (>=0.1.2,<0.2.0)", "streamlit (>=1.18.0,<2.0.0)", "sympy (>=1.12,<2.0)", "telethon (>=1.28.5,<2.0.0)", "timescale-vector (>=0.0.1,<0.0.2)", "tqdm (>=4.48.0)", "upstash-redis (>=0.15.0,<0.16.0)", "xata (>=1.0.0a7,<2.0.0)", "xmltodict (>=0.13.0,<0.14.0)"]
 javascript = ["esprima (>=4.0.1,<5.0.0)"]
 llms = ["clarifai (>=9.1.0)", "cohere (>=4,<6)", "huggingface_hub (>=0,<1)", "manifest-ml (>=0.0.1,<0.0.2)", "nlpcloud (>=1,<2)", "openai (<2)", "openlm (>=0.0.5,<0.0.6)", "torch (>=1,<3)", "transformers (>=4,<5)"]
-openai = ["openai (<2)", "tiktoken (>=0.3.2,<0.6.0) ; python_version >= \"3.9\""]
-qdrant = ["qdrant-client (>=1.3.1,<2.0.0) ; python_full_version >= \"3.8.1\" and python_version < \"3.12\""]
+openai = ["openai (<2)", "tiktoken (>=0.3.2,<0.6.0)"]
+qdrant = ["qdrant-client (>=1.3.1,<2.0.0)"]
 text-helpers = ["chardet (>=5.1.0,<6.0.0)"]
 
 [[package]]
@@ -1986,7 +2028,7 @@ description = "Community contributed LangChain integrations."
 optional = true
 python-versions = "<4.0,>=3.8.1"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "langchain_community-0.0.32-py3-none-any.whl", hash = "sha256:406977009999952d0705de3806de2b4867e9bb8eda8ca154a59c7a8ed58da38d"},
     {file = "langchain_community-0.0.32.tar.gz", hash = "sha256:1510217d646c8380f54e9850351f6d2a0b0dd73c501b666c6f4b40baa8160b29"},
@@ -2005,7 +2047,7 @@ tenacity = ">=8.1.0,<9.0.0"
 
 [package.extras]
 cli = ["typer (>=0.9.0,<0.10.0)"]
-extended-testing = ["aiosqlite (>=0.19.0,<0.20.0)", "aleph-alpha-client (>=2.15.0,<3.0.0)", "anthropic (>=0.3.11,<0.4.0)", "arxiv (>=1.4,<2.0)", "assemblyai (>=0.17.0,<0.18.0)", "atlassian-python-api (>=3.36.0,<4.0.0)", "azure-ai-documentintelligence (>=1.0.0b1,<2.0.0)", "beautifulsoup4 (>=4,<5)", "bibtexparser (>=1.4.0,<2.0.0)", "cassio (>=0.1.0,<0.2.0)", "chardet (>=5.1.0,<6.0.0)", "cloudpickle (>=2.0.0)", "cohere (>=4,<5)", "databricks-vectorsearch (>=0.21,<0.22)", "datasets (>=2.15.0,<3.0.0)", "dgml-utils (>=0.3.0,<0.4.0)", "elasticsearch (>=8.12.0,<9.0.0)", "esprima (>=4.0.1,<5.0.0)", "faiss-cpu (>=1,<2)", "feedparser (>=6.0.10,<7.0.0)", "fireworks-ai (>=0.9.0,<0.10.0)", "friendli-client (>=1.2.4,<2.0.0)", "geopandas (>=0.13.1,<0.14.0)", "gitpython (>=3.1.32,<4.0.0)", "google-cloud-documentai (>=2.20.1,<3.0.0)", "gql (>=3.4.1,<4.0.0)", "gradientai (>=1.4.0,<2.0.0)", "hdbcli (>=2.19.21,<3.0.0)", "hologres-vector (>=0.0.6,<0.0.7)", "html2text (>=2020.1.16,<2021.0.0)", "httpx (>=0.24.1,<0.25.0)", "httpx-sse (>=0.4.0,<0.5.0)", "javelin-sdk (>=0.1.8,<0.2.0)", "jinja2 (>=3,<4)", "jq (>=1.4.1,<2.0.0)", "jsonschema (>1)", "lxml (>=4.9.3,<6.0)", "markdownify (>=0.11.6,<0.12.0)", "motor (>=3.3.1,<4.0.0)", "msal (>=1.25.0,<2.0.0)", "mwparserfromhell (>=0.6.4,<0.7.0)", "mwxml (>=0.3.3,<0.4.0)", "newspaper3k (>=0.2.8,<0.3.0)", "numexpr (>=2.8.6,<3.0.0)", "nvidia-riva-client (>=2.14.0,<3.0.0)", "oci (>=2.119.1,<3.0.0)", "openai (<2)", "openapi-pydantic (>=0.3.2,<0.4.0)", "oracle-ads (>=2.9.1,<3.0.0)", "pandas (>=2.0.1,<3.0.0)", "pdfminer-six (>=20221105,<20221106)", "pgvector (>=0.1.6,<0.2.0)", "praw (>=7.7.1,<8.0.0)", "premai (>=0.3.25,<0.4.0)", "psychicapi (>=0.8.0,<0.9.0)", "py-trello (>=0.19.0,<0.20.0)", "pyjwt (>=2.8.0,<3.0.0)", "pymupdf (>=1.22.3,<2.0.0)", "pypdf (>=3.4.0,<4.0.0)", "pypdfium2 (>=4.10.0,<5.0.0)", "pyspark (>=3.4.0,<4.0.0)", "rank-bm25 (>=0.2.2,<0.3.0)", "rapidfuzz (>=3.1.1,<4.0.0)", "rapidocr-onnxruntime (>=1.3.2,<2.0.0) ; python_full_version >= \"3.8.1\" and python_version < \"3.12\"", "rdflib (==7.0.0)", "requests-toolbelt (>=1.0.0,<2.0.0)", "rspace_client (>=2.5.0,<3.0.0)", "scikit-learn (>=1.2.2,<2.0.0)", "sqlite-vss (>=0.1.2,<0.2.0)", "streamlit (>=1.18.0,<2.0.0) ; python_full_version >= \"3.8.1\" and python_full_version != \"3.9.7\" and python_version < \"4.0\"", "sympy (>=1.12,<2.0)", "telethon (>=1.28.5,<2.0.0)", "tidb-vector (>=0.0.3,<1.0.0)", "timescale-vector (>=0.0.1,<0.0.2)", "tqdm (>=4.48.0)", "tree-sitter (>=0.20.2,<0.21.0)", "tree-sitter-languages (>=1.8.0,<2.0.0)", "upstash-redis (>=0.15.0,<0.16.0)", "vdms (>=0.0.20,<0.0.21)", "xata (>=1.0.0a7,<2.0.0)", "xmltodict (>=0.13.0,<0.14.0)"]
+extended-testing = ["aiosqlite (>=0.19.0,<0.20.0)", "aleph-alpha-client (>=2.15.0,<3.0.0)", "anthropic (>=0.3.11,<0.4.0)", "arxiv (>=1.4,<2.0)", "assemblyai (>=0.17.0,<0.18.0)", "atlassian-python-api (>=3.36.0,<4.0.0)", "azure-ai-documentintelligence (>=1.0.0b1,<2.0.0)", "beautifulsoup4 (>=4,<5)", "bibtexparser (>=1.4.0,<2.0.0)", "cassio (>=0.1.0,<0.2.0)", "chardet (>=5.1.0,<6.0.0)", "cloudpickle (>=2.0.0)", "cohere (>=4,<5)", "databricks-vectorsearch (>=0.21,<0.22)", "datasets (>=2.15.0,<3.0.0)", "dgml-utils (>=0.3.0,<0.4.0)", "elasticsearch (>=8.12.0,<9.0.0)", "esprima (>=4.0.1,<5.0.0)", "faiss-cpu (>=1,<2)", "feedparser (>=6.0.10,<7.0.0)", "fireworks-ai (>=0.9.0,<0.10.0)", "friendli-client (>=1.2.4,<2.0.0)", "geopandas (>=0.13.1,<0.14.0)", "gitpython (>=3.1.32,<4.0.0)", "google-cloud-documentai (>=2.20.1,<3.0.0)", "gql (>=3.4.1,<4.0.0)", "gradientai (>=1.4.0,<2.0.0)", "hdbcli (>=2.19.21,<3.0.0)", "hologres-vector (>=0.0.6,<0.0.7)", "html2text (>=2020.1.16,<2021.0.0)", "httpx (>=0.24.1,<0.25.0)", "httpx-sse (>=0.4.0,<0.5.0)", "javelin-sdk (>=0.1.8,<0.2.0)", "jinja2 (>=3,<4)", "jq (>=1.4.1,<2.0.0)", "jsonschema (>1)", "lxml (>=4.9.3,<6.0)", "markdownify (>=0.11.6,<0.12.0)", "motor (>=3.3.1,<4.0.0)", "msal (>=1.25.0,<2.0.0)", "mwparserfromhell (>=0.6.4,<0.7.0)", "mwxml (>=0.3.3,<0.4.0)", "newspaper3k (>=0.2.8,<0.3.0)", "numexpr (>=2.8.6,<3.0.0)", "nvidia-riva-client (>=2.14.0,<3.0.0)", "oci (>=2.119.1,<3.0.0)", "openai (<2)", "openapi-pydantic (>=0.3.2,<0.4.0)", "oracle-ads (>=2.9.1,<3.0.0)", "pandas (>=2.0.1,<3.0.0)", "pdfminer-six (>=20221105,<20221106)", "pgvector (>=0.1.6,<0.2.0)", "praw (>=7.7.1,<8.0.0)", "premai (>=0.3.25,<0.4.0)", "psychicapi (>=0.8.0,<0.9.0)", "py-trello (>=0.19.0,<0.20.0)", "pyjwt (>=2.8.0,<3.0.0)", "pymupdf (>=1.22.3,<2.0.0)", "pypdf (>=3.4.0,<4.0.0)", "pypdfium2 (>=4.10.0,<5.0.0)", "pyspark (>=3.4.0,<4.0.0)", "rank-bm25 (>=0.2.2,<0.3.0)", "rapidfuzz (>=3.1.1,<4.0.0)", "rapidocr-onnxruntime (>=1.3.2,<2.0.0)", "rdflib (==7.0.0)", "requests-toolbelt (>=1.0.0,<2.0.0)", "rspace_client (>=2.5.0,<3.0.0)", "scikit-learn (>=1.2.2,<2.0.0)", "sqlite-vss (>=0.1.2,<0.2.0)", "streamlit (>=1.18.0,<2.0.0)", "sympy (>=1.12,<2.0)", "telethon (>=1.28.5,<2.0.0)", "tidb-vector (>=0.0.3,<1.0.0)", "timescale-vector (>=0.0.1,<0.0.2)", "tqdm (>=4.48.0)", "tree-sitter (>=0.20.2,<0.21.0)", "tree-sitter-languages (>=1.8.0,<2.0.0)", "upstash-redis (>=0.15.0,<0.16.0)", "vdms (>=0.0.20,<0.0.21)", "xata (>=1.0.0a7,<2.0.0)", "xmltodict (>=0.13.0,<0.14.0)"]
 
 [[package]]
 name = "langchain-core"
@@ -2014,6 +2056,7 @@ description = "Building applications with LLMs through composability"
 optional = true
 python-versions = "<4.0,>=3.8.1"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "langchain_core-0.1.42-py3-none-any.whl", hash = "sha256:c5653ffa08a44f740295c157a24c0def4a753333f6a2c41f76bf431cd00be8b5"},
     {file = "langchain_core-0.1.42.tar.gz", hash = "sha256:40751bf60ea5d8e2b2efe65290db434717ee3834870c002e40e2811f09d814e6"},
@@ -2037,7 +2080,7 @@ description = "LangChain text splitting utilities"
 optional = true
 python-versions = "<4.0,>=3.8.1"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "langchain_text_splitters-0.0.2-py3-none-any.whl", hash = "sha256:13887f32705862c1e1454213cb7834a63aae57c26fcd80346703a1d09c46168d"},
     {file = "langchain_text_splitters-0.0.2.tar.gz", hash = "sha256:ac8927dc0ba08eba702f6961c9ed7df7cead8de19a9f7101ab2b5ea34201b3c1"},
@@ -2056,7 +2099,7 @@ description = "Language detection library ported from Google's language-detectio
 optional = true
 python-versions = "*"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "langdetect-1.0.9-py2-none-any.whl", hash = "sha256:7cbc0746252f19e76f77c0b1690aadf01963be835ef0cd4b56dddf2a8f1dfc2a"},
     {file = "langdetect-1.0.9.tar.gz", hash = "sha256:cbc1fef89f8d062739774bd51eda3da3274006b3661d199c2655f6b3f6d605a0"},
@@ -2072,6 +2115,7 @@ description = "Client library to connect to the LangSmith LLM Tracing and Evalua
 optional = true
 python-versions = "<4.0,>=3.8.1"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "langsmith-0.1.147-py3-none-any.whl", hash = "sha256:7166fc23b965ccf839d64945a78e9f1157757add228b086141eb03a60d699a15"},
     {file = "langsmith-0.1.147.tar.gz", hash = "sha256:2e933220318a4e73034657103b3b1a3a6109cc5db3566a7e8e03be8d6d7def7a"},
@@ -2097,6 +2141,7 @@ description = "Links recognition library with FULL unicode support."
 optional = false
 python-versions = ">=3.7"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048"},
     {file = "linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79"},
@@ -2118,7 +2163,7 @@ description = "Powerful and Pythonic XML processing library combining libxml2/li
 optional = true
 python-versions = ">=3.6"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "lxml-5.3.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:dd36439be765e2dde7660212b5275641edbc813e7b24668831a5c8ac91180656"},
     {file = "lxml-5.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ae5fe5c4b525aa82b8076c1a59d642c17b6e8739ecf852522c6321852178119d"},
@@ -2274,7 +2319,7 @@ description = "Python implementation of John Gruber's Markdown."
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "Markdown-3.7-py3-none-any.whl", hash = "sha256:7eb6df5690b81a1d7942992c97fad2938e956e79df20cbc6186e9c3a77b1c803"},
     {file = "markdown-3.7.tar.gz", hash = "sha256:2ae2471477cfd02dbbf038d5d9bc226d40def84b4fe2986e49b59b6b472bbed2"},
@@ -2291,6 +2336,7 @@ description = "Python port of markdown-it. Markdown parsing, done right!"
 optional = false
 python-versions = ">=3.8"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"},
     {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"},
@@ -2318,6 +2364,7 @@ description = "Safely add untrusted strings to HTML/XML markup."
 optional = false
 python-versions = ">=3.9"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8"},
     {file = "MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158"},
@@ -2389,7 +2436,7 @@ description = "A lightweight library for converting complex datatypes to and fro
 optional = true
 python-versions = ">=3.9"
 groups = ["main"]
-markers = "extra == \"vector-db-based\" or extra == \"file-based\""
+markers = "(extra == \"vector-db-based\" or extra == \"file-based\") and (python_version <= \"3.11\" or python_version >= \"3.12\")"
 files = [
     {file = "marshmallow-3.25.1-py3-none-any.whl", hash = "sha256:ec5d00d873ce473b7f2ffcb7104286a376c354cab0c2fa12f5573dab03e87210"},
     {file = "marshmallow-3.25.1.tar.gz", hash = "sha256:f4debda3bb11153d81ac34b0d582bf23053055ee11e791b54b4b35493468040a"},
@@ -2410,7 +2457,7 @@ description = "Python plotting package"
 optional = true
 python-versions = ">=3.10"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "matplotlib-3.10.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2c5829a5a1dd5a71f0e31e6e8bb449bc0ee9dbfb05ad28fc0c6b55101b3a4be6"},
     {file = "matplotlib-3.10.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2a43cbefe22d653ab34bb55d42384ed30f611bcbdea1f8d7f431011a2e1c62e"},
@@ -2469,6 +2516,7 @@ description = "McCabe checker, plugin for flake8"
 optional = false
 python-versions = ">=3.6"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"},
     {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"},
@@ -2481,6 +2529,7 @@ description = "Collection of plugins for markdown-it-py"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "mdit_py_plugins-0.4.2-py3-none-any.whl", hash = "sha256:0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636"},
     {file = "mdit_py_plugins-0.4.2.tar.gz", hash = "sha256:5f2cd1fdb606ddf152d37ec30e46101a60512bc0e5fa1a7002c36647b09e26b5"},
@@ -2501,6 +2550,7 @@ description = "Markdown URL utilities"
 optional = false
 python-versions = ">=3.7"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"},
     {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"},
@@ -2513,6 +2563,7 @@ description = "A memory profiler for Python applications"
 optional = false
 python-versions = ">=3.7.0"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "memray-1.15.0-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:9b623c0c651d611dd068236566a8a202250e3d59307c3a3f241acc47835e73eb"},
     {file = "memray-1.15.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:74765f92887b7eed152e3b9f14c147c43bf0247417b18c7ea0dec173cd01633c"},
@@ -2566,10 +2617,10 @@ textual = ">=0.41.0"
 
 [package.extras]
 benchmark = ["asv"]
-dev = ["Cython", "IPython", "asv", "black", "bump2version", "check-manifest", "flake8", "furo", "greenlet ; python_version < \"3.14\"", "ipython", "isort", "mypy", "packaging", "pytest", "pytest-cov", "pytest-textual-snapshot", "setuptools ; python_version >= \"3.12\"", "sphinx", "sphinx-argparse", "textual (>=0.43,!=0.65.2,!=0.66)", "towncrier"]
+dev = ["Cython", "IPython", "asv", "black", "bump2version", "check-manifest", "flake8", "furo", "greenlet", "ipython", "isort", "mypy", "packaging", "pytest", "pytest-cov", "pytest-textual-snapshot", "setuptools", "sphinx", "sphinx-argparse", "textual (>=0.43,!=0.65.2,!=0.66)", "towncrier"]
 docs = ["IPython", "bump2version", "furo", "sphinx", "sphinx-argparse", "towncrier"]
 lint = ["black", "check-manifest", "flake8", "isort", "mypy"]
-test = ["Cython", "greenlet ; python_version < \"3.14\"", "ipython", "packaging", "pytest", "pytest-cov", "pytest-textual-snapshot", "setuptools ; python_version >= \"3.12\"", "textual (>=0.43,!=0.65.2,!=0.66)"]
+test = ["Cython", "greenlet", "ipython", "packaging", "pytest", "pytest-cov", "pytest-textual-snapshot", "setuptools", "textual (>=0.43,!=0.65.2,!=0.66)"]
 
 [[package]]
 name = "multidict"
@@ -2578,7 +2629,7 @@ description = "multidict implementation"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "multidict-6.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3380252550e372e8511d49481bd836264c009adb826b23fefcc5dd3c69692f60"},
     {file = "multidict-6.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:99f826cbf970077383d7de805c0681799491cb939c25450b9b5b3ced03ca99f1"},
@@ -2684,6 +2735,7 @@ description = "Optional static typing for Python"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "mypy-1.14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:52686e37cf13d559f668aa398dd7ddf1f92c5d613e4f8cb262be2fb4fedb0fcb"},
     {file = "mypy-1.14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1fb545ca340537d4b45d3eecdb3def05e913299ca72c290326be19b3804b39c0"},
@@ -2748,7 +2800,7 @@ files = [
     {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"},
     {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"},
 ]
-markers = {main = "extra == \"vector-db-based\" or extra == \"file-based\""}
+markers = {main = "(extra == \"vector-db-based\" or extra == \"file-based\") and (python_version <= \"3.11\" or python_version >= \"3.12\")", dev = "python_version <= \"3.11\" or python_version >= \"3.12\""}
 
 [[package]]
 name = "nltk"
@@ -2757,6 +2809,7 @@ description = "Natural Language Toolkit"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "nltk-3.9.1-py3-none-any.whl", hash = "sha256:4fa26829c5b00715afe3061398a8989dc643b92ce7dd93fb4585a70930d168a1"},
     {file = "nltk-3.9.1.tar.gz", hash = "sha256:87d127bd3de4bd89a4f81265e5fa59cb1b199b27440175370f7417d2bc7ae868"},
@@ -2783,6 +2836,7 @@ description = "Fundamental package for array computing in Python"
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0"},
     {file = "numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a"},
@@ -2829,7 +2883,7 @@ description = "Python client library for the OpenAI API"
 optional = true
 python-versions = ">=3.7.1"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "openai-0.27.9-py3-none-any.whl", hash = "sha256:6a3cf8e276d1a6262b50562fbc0cba7967cfebb78ed827d375986b48fdad6475"},
     {file = "openai-0.27.9.tar.gz", hash = "sha256:b687761c82f5ebb6f61efc791b2083d2d068277b94802d4d1369efe39851813d"},
@@ -2862,7 +2916,7 @@ description = "A Python library to read/write Excel 2010 xlsx/xlsm files"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2"},
     {file = "openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050"},
@@ -2878,6 +2932,7 @@ description = "Fast, correct Python JSON library supporting dataclasses, datetim
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "orjson-3.10.15-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:552c883d03ad185f720d0c09583ebde257e41b9521b74ff40e08b7dec4559c04"},
     {file = "orjson-3.10.15-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:616e3e8d438d02e4854f70bfdc03a6bcdb697358dbaa6bcd19cbe24d24ece1f8"},
@@ -2967,6 +3022,7 @@ description = "Core utilities for Python packages"
 optional = false
 python-versions = ">=3.7"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "packaging-23.2-py3-none-any.whl", hash = "sha256:8c491190033a9af7e1d931d0b5dacc2ef47509b34dd0de67ed209b5203fc88c7"},
     {file = "packaging-23.2.tar.gz", hash = "sha256:048fb0e9405036518eaaf48a55953c750c11e1a1b68e0dd1a9d62ed0c092cfc5"},
@@ -2979,6 +3035,7 @@ description = "Powerful data structures for data analysis, time series, and stat
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pandas-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:90c6fca2acf139569e74e8781709dccb6fe25940488755716d1d354d6bc58bce"},
     {file = "pandas-2.2.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c7adfc142dac335d8c1e0dcbd37eb8617eac386596eb9e1a1b77791cf2498238"},
@@ -3013,9 +3070,9 @@ files = [
 
 [package.dependencies]
 numpy = [
+    {version = ">=1.22.4", markers = "python_version < \"3.11\""},
     {version = ">=1.23.2", markers = "python_version == \"3.11\""},
     {version = ">=1.26.0", markers = "python_version >= \"3.12\""},
-    {version = ">=1.22.4", markers = "python_version < \"3.11\""},
 ]
 python-dateutil = ">=2.8.2"
 pytz = ">=2020.1"
@@ -3053,7 +3110,7 @@ description = "Type annotations for pandas"
 optional = true
 python-versions = ">=3.10"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "pandas_stubs-2.2.3.241126-py3-none-any.whl", hash = "sha256:74aa79c167af374fe97068acc90776c0ebec5266a6e5c69fe11e9c2cf51f2267"},
     {file = "pandas_stubs-2.2.3.241126.tar.gz", hash = "sha256:cf819383c6d9ae7d4dabf34cd47e1e45525bb2f312e6ad2939c2c204cb708acd"},
@@ -3070,6 +3127,7 @@ description = "Bring colors to your terminal."
 optional = false
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pastel-0.2.1-py2.py3-none-any.whl", hash = "sha256:4349225fcdf6c2bb34d483e523475de5bb04a5c10ef711263452cb37d7dd4364"},
     {file = "pastel-0.2.1.tar.gz", hash = "sha256:e6581ac04e973cac858828c6202c1e1e81fee1dc7de7683f3e1ffe0bfd8a573d"},
@@ -3082,7 +3140,7 @@ description = "A wrapper around the pdftoppm and pdftocairo command line tools t
 optional = true
 python-versions = "*"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "pdf2image-1.16.3-py3-none-any.whl", hash = "sha256:b6154164af3677211c22cbb38b2bd778b43aca02758e962fe1e231f6d3b0e380"},
     {file = "pdf2image-1.16.3.tar.gz", hash = "sha256:74208810c2cef4d9e347769b8e62a52303982ddb4f2dfd744c7ab4b940ae287e"},
@@ -3098,7 +3156,7 @@ description = "PDF parser and analyzer"
 optional = true
 python-versions = ">=3.6"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "pdfminer.six-20221105-py3-none-any.whl", hash = "sha256:1eaddd712d5b2732f8ac8486824533514f8ba12a0787b3d5fe1e686cd826532d"},
     {file = "pdfminer.six-20221105.tar.gz", hash = "sha256:8448ab7b939d18b64820478ecac5394f482d7a79f5f7eaa7703c6c959c175e1d"},
@@ -3120,6 +3178,7 @@ description = "API Documentation for Python Projects"
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pdoc-15.0.1-py3-none-any.whl", hash = "sha256:fd437ab8eb55f9b942226af7865a3801e2fb731665199b74fd9a44737dbe20f9"},
     {file = "pdoc-15.0.1.tar.gz", hash = "sha256:3b08382c9d312243ee6c2a1813d0ff517a6ab84d596fa2c6c6b5255b17c3d666"},
@@ -3137,7 +3196,7 @@ description = "Python Imaging Library (Fork)"
 optional = true
 python-versions = ">=3.9"
 groups = ["main"]
-markers = "extra == \"vector-db-based\" or extra == \"file-based\""
+markers = "(extra == \"vector-db-based\" or extra == \"file-based\") and (python_version <= \"3.11\" or python_version >= \"3.12\")"
 files = [
     {file = "pillow-11.1.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:e1abe69aca89514737465752b4bcaf8016de61b3be1397a8fc260ba33321b3a8"},
     {file = "pillow-11.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c640e5a06869c75994624551f45e5506e4256562ead981cce820d5ab39ae2192"},
@@ -3217,7 +3276,7 @@ docs = ["furo", "olefile", "sphinx (>=8.1)", "sphinx-copybutton", "sphinx-inline
 fpx = ["olefile"]
 mic = ["olefile"]
 tests = ["check-manifest", "coverage (>=7.4.2)", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout", "trove-classifiers (>=2024.10.12)"]
-typing = ["typing-extensions ; python_version < \"3.10\""]
+typing = ["typing-extensions"]
 xmp = ["defusedxml"]
 
 [[package]]
@@ -3227,6 +3286,7 @@ description = "A small Python package for determining appropriate platform-speci
 optional = false
 python-versions = ">=3.8"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"},
     {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"},
@@ -3244,7 +3304,7 @@ description = "An open-source, interactive data visualization library for Python
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "plotly-5.24.1-py3-none-any.whl", hash = "sha256:f67073a1e637eb0dc3e46324d9d51e2fe76e9727c892dde64ddf1e1b51f29089"},
     {file = "plotly-5.24.1.tar.gz", hash = "sha256:dbc8ac8339d248a4bcc36e08a5659bacfe1b079390b8953533f4eb22169b4bae"},
@@ -3261,6 +3321,7 @@ description = "plugin and hook calling mechanisms for python"
 optional = false
 python-versions = ">=3.8"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
     {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
@@ -3277,6 +3338,7 @@ description = "A task runner that works well with poetry."
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "poethepoet-0.24.4-py3-none-any.whl", hash = "sha256:fb4ea35d7f40fe2081ea917d2e4102e2310fda2cde78974050ca83896e229075"},
     {file = "poethepoet-0.24.4.tar.gz", hash = "sha256:ff4220843a87c888cbcb5312c8905214701d0af60ac7271795baa8369b428fef"},
@@ -3296,7 +3358,7 @@ description = "Accelerated property cache"
 optional = true
 python-versions = ">=3.9"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "propcache-0.2.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:6b3f39a85d671436ee3d12c017f8fdea38509e4f25b28eb25877293c98c243f6"},
     {file = "propcache-0.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:39d51fbe4285d5db5d92a929e3e21536ea3dd43732c5b177c7ef03f918dff9f2"},
@@ -3389,6 +3451,7 @@ description = "Beautiful, Pythonic protocol buffers"
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "proto_plus-1.26.1-py3-none-any.whl", hash = "sha256:13285478c2dcf2abb829db158e1047e2f1e8d63a077d94263c2b88b043c75a66"},
     {file = "proto_plus-1.26.1.tar.gz", hash = "sha256:21a515a4c4c0088a773899e23c7bbade3d18f9c66c73edd4c7ee3816bc96a012"},
@@ -3407,6 +3470,7 @@ description = ""
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "protobuf-6.30.2-cp310-abi3-win32.whl", hash = "sha256:b12ef7df7b9329886e66404bef5e9ce6a26b54069d7f7436a0853ccdeb91c103"},
     {file = "protobuf-6.30.2-cp310-abi3-win_amd64.whl", hash = "sha256:7653c99774f73fe6b9301b87da52af0e69783a2e371e8b599b3e9cb4da4b12b9"},
@@ -3426,6 +3490,7 @@ description = "Cross-platform lib for process and system monitoring in Python."
 optional = false
 python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "psutil-6.1.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:ff34df86226c0227c52f38b919213157588a678d049688eded74c76c8ba4a5d0"},
     {file = "psutil-6.1.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:c0e0c00aa18ca2d3b2b991643b799a15fc8f0563d2ebb6040f64ce8dc027b942"},
@@ -3457,7 +3522,7 @@ description = "Python library for Apache Arrow"
 optional = true
 python-versions = ">=3.9"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "pyarrow-19.0.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:fc28912a2dc924dddc2087679cc8b7263accc71b9ff025a1362b004711661a69"},
     {file = "pyarrow-19.0.1-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:fca15aabbe9b8355800d923cc2e82c8ef514af321e18b437c3d782aa884eaeec"},
@@ -3513,6 +3578,7 @@ description = "Pure-Python implementation of ASN.1 types and DER/BER/CER codecs
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629"},
     {file = "pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034"},
@@ -3525,6 +3591,7 @@ description = "A collection of ASN.1-based protocols modules"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a"},
     {file = "pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6"},
@@ -3540,6 +3607,7 @@ description = "Python style guide checker"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pycodestyle-2.11.1-py2.py3-none-any.whl", hash = "sha256:44fe31000b2d866f2e41841b18528a505fbd7fef9017b04eff4e2648a0fadc67"},
     {file = "pycodestyle-2.11.1.tar.gz", hash = "sha256:41ba0e7afc9752dfb53ced5489e89f8186be00e599e712660695b7a75ff2663f"},
@@ -3552,7 +3620,7 @@ description = "C parser in Python"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "platform_python_implementation != \"PyPy\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and platform_python_implementation != \"PyPy\""
 files = [
     {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"},
     {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"},
@@ -3565,6 +3633,7 @@ description = "Data validation using Python type hints"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pydantic-2.10.5-py3-none-any.whl", hash = "sha256:4dd4e322dbe55472cb7ca7e73f4b63574eecccf2835ffa2af9021ce113c83c53"},
     {file = "pydantic-2.10.5.tar.gz", hash = "sha256:278b38dbbaec562011d659ee05f63346951b3a248a6f3642e1bc68894ea2b4ff"},
@@ -3577,7 +3646,7 @@ typing-extensions = ">=4.12.2"
 
 [package.extras]
 email = ["email-validator (>=2.0.0)"]
-timezone = ["tzdata ; python_version >= \"3.9\" and platform_system == \"Windows\""]
+timezone = ["tzdata"]
 
 [[package]]
 name = "pydantic-core"
@@ -3586,6 +3655,7 @@ description = "Core functionality for Pydantic validation and serialization"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pydantic_core-2.27.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2d367ca20b2f14095a8f4fa1210f5a7b78b8a20009ecced6b12818f455b1e9fa"},
     {file = "pydantic_core-2.27.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:491a2b73db93fab69731eaee494f320faa4e093dbed776be1a829c2eb222c34c"},
@@ -3692,6 +3762,25 @@ files = [
 [package.dependencies]
 typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0"
 
+[[package]]
+name = "pydash"
+version = "7.0.7"
+description = "The kitchen sink of Python utility libraries for doing \"stuff\" in a functional way. Based on the Lo-Dash Javascript library."
+optional = false
+python-versions = ">=3.8"
+groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
+files = [
+    {file = "pydash-7.0.7-py3-none-any.whl", hash = "sha256:c3c5b54eec0a562e0080d6f82a14ad4d5090229847b7e554235b5c1558c745e1"},
+    {file = "pydash-7.0.7.tar.gz", hash = "sha256:cc935d5ac72dd41fb4515bdf982e7c864c8b5eeea16caffbab1936b849aaa49a"},
+]
+
+[package.dependencies]
+typing-extensions = ">=3.10,<4.6.0 || >4.6.0"
+
+[package.extras]
+dev = ["black", "build", "coverage", "docformatter", "flake8", "flake8-black", "flake8-bugbear", "flake8-isort", "furo", "invoke", "isort", "mypy", "pylint", "pytest", "pytest-cov", "pytest-mypy-testing", "sphinx", "sphinx-autodoc-typehints", "tox", "twine", "wheel"]
+
 [[package]]
 name = "pyflakes"
 version = "3.1.0"
@@ -3699,6 +3788,7 @@ description = "passive checker of Python programs"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pyflakes-3.1.0-py2.py3-none-any.whl", hash = "sha256:4132f6d49cb4dae6819e5379898f2b8cce3c5f23994194c24b77d5da2e36f774"},
     {file = "pyflakes-3.1.0.tar.gz", hash = "sha256:a0aae034c444db0071aa077972ba4768d40c830d9539fd45bf4cd3f8f6992efc"},
@@ -3711,6 +3801,7 @@ description = "Pygments is a syntax highlighting package written in Python."
 optional = false
 python-versions = ">=3.8"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c"},
     {file = "pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f"},
@@ -3726,6 +3817,7 @@ description = "JSON Web Token implementation in Python"
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb"},
     {file = "pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953"},
@@ -3744,6 +3836,7 @@ description = "A development tool to measure, monitor and analyze the memory beh
 optional = false
 python-versions = ">=3.6"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "Pympler-1.1-py3-none-any.whl", hash = "sha256:5b223d6027d0619584116a0cbc28e8d2e378f7a79c1e5e024f9ff3b673c58506"},
     {file = "pympler-1.1.tar.gz", hash = "sha256:1eaa867cb8992c218430f1708fdaccda53df064144d1c5656b1e6f1ee6000424"},
@@ -3759,7 +3852,7 @@ description = "pyparsing module - Classes and methods to define and execute pars
 optional = true
 python-versions = ">=3.9"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "pyparsing-3.2.1-py3-none-any.whl", hash = "sha256:506ff4f4386c4cec0590ec19e6302d3aedb992fdc02c761e90416f158dacf8e1"},
     {file = "pyparsing-3.2.1.tar.gz", hash = "sha256:61980854fd66de3a90028d679a954d5f2623e83144b5afe5ee86f43d762e5f0a"},
@@ -3775,6 +3868,7 @@ description = "pyproject-flake8 (`pflake8`), a monkey patching wrapper to connec
 optional = false
 python-versions = ">=3.8.1"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pyproject_flake8-6.1.0-py3-none-any.whl", hash = "sha256:86ea5559263c098e1aa4f866776aa2cf45362fd91a576b9fd8fbbbb55db12c4e"},
     {file = "pyproject_flake8-6.1.0.tar.gz", hash = "sha256:6da8e5a264395e0148bc11844c6fb50546f1fac83ac9210f7328664135f9e70f"},
@@ -3791,6 +3885,7 @@ description = "Python Rate-Limiter using Leaky-Bucket Algorithm"
 optional = false
 python-versions = ">=3.8,<4.0"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pyrate_limiter-3.1.1-py3-none-any.whl", hash = "sha256:c51906f1d51d56dc992ff6c26e8300e32151bc6cfa3e6559792e31971dfd4e2b"},
     {file = "pyrate_limiter-3.1.1.tar.gz", hash = "sha256:2f57eda712687e6eccddf6afe8f8a15b409b97ed675fe64a626058f12863b7b7"},
@@ -3807,6 +3902,7 @@ description = "Persistent/Functional/Immutable data structures"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pyrsistent-0.20.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8c3aba3e01235221e5b229a6c05f585f344734bd1ad42a8ac51493d74722bbce"},
     {file = "pyrsistent-0.20.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1beb78af5423b879edaf23c5591ff292cf7c33979734c99aa66d5914ead880f"},
@@ -3849,7 +3945,7 @@ description = "Python-tesseract is a python wrapper for Google's Tesseract-OCR"
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "pytesseract-0.3.10-py3-none-any.whl", hash = "sha256:8f22cc98f765bf13517ead0c70effedb46c153540d25783e04014f28b55a5fc6"},
     {file = "pytesseract-0.3.10.tar.gz", hash = "sha256:f1c3a8b0f07fd01a1085d451f5b8315be6eec1d5577a6796d46dc7a62bd4120f"},
@@ -3866,6 +3962,7 @@ description = "pytest: simple powerful testing with Python"
 optional = false
 python-versions = ">=3.7"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pytest-7.4.4-py3-none-any.whl", hash = "sha256:b090cdf5ed60bf4c45261be03239c2c1c22df034fbffe691abe93cd80cea01d8"},
     {file = "pytest-7.4.4.tar.gz", hash = "sha256:2cf0005922c6ace4a3e2ec8b4080eb0d9753fdc93107415332f50ce9e7994280"},
@@ -3889,6 +3986,7 @@ description = "Pytest plugin for measuring coverage."
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pytest-cov-6.0.0.tar.gz", hash = "sha256:fde0b595ca248bb8e2d76f020b465f3b107c9632e6a1d1705f17834c89dcadc0"},
     {file = "pytest_cov-6.0.0-py3-none-any.whl", hash = "sha256:eee6f1b9e61008bd34975a4d5bab25801eb31898b032dd55addc93e96fcaaa35"},
@@ -3908,6 +4006,7 @@ description = "pytest-httpserver is a httpserver for pytest"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pytest_httpserver-1.1.1-py3-none-any.whl", hash = "sha256:aadc744bfac773a2ea93d05c2ef51fa23c087e3cc5dace3ea9d45cdd4bfe1fe8"},
     {file = "pytest_httpserver-1.1.1.tar.gz", hash = "sha256:e5c46c62c0aa65e5d4331228cb2cb7db846c36e429c3e74ca806f284806bf7c6"},
@@ -3923,6 +4022,7 @@ description = "A simple plugin to use with pytest"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pytest_memray-1.7.0-py3-none-any.whl", hash = "sha256:b896718c1adf6d0cd339dfaaaa5620f035c9919e1199a79b3453804a1254306f"},
     {file = "pytest_memray-1.7.0.tar.gz", hash = "sha256:c18fa907d2210b42f4096c093e2d3416dfc002dcaa450ef3f9ba819bc3dd8f5f"},
@@ -3944,6 +4044,7 @@ description = "Thin-wrapper around the mock package for easier use with pytest"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pytest-mock-3.14.0.tar.gz", hash = "sha256:2719255a1efeceadbc056d6bf3df3d1c5015530fb40cf347c0f9afac88410bd0"},
     {file = "pytest_mock-3.14.0-py3-none-any.whl", hash = "sha256:0b72c38033392a5f4621342fe11e9219ac11ec9d375f8e2a0c164539e0d70f6f"},
@@ -3962,7 +4063,7 @@ description = "Python binding for Rust's library for reading excel and odf file
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "python_calamine-0.2.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:f292a03591b1cab1537424851b74baa33b0a55affc315248a7592ba3de1c3e83"},
     {file = "python_calamine-0.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6cfbd23d1147f53fd70fddfb38af2a98896ecad069c9a4120e77358a6fc43b39"},
@@ -4073,6 +4174,7 @@ description = "Extensions to the standard Python datetime module"
 optional = false
 python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"},
     {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"},
@@ -4088,7 +4190,7 @@ description = "Create, read, and update Microsoft Word .docx files."
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "python_docx-1.1.2-py3-none-any.whl", hash = "sha256:08c20d6058916fb19853fcf080f7f42b6270d89eac9fa5f8c15f691c0017fabe"},
     {file = "python_docx-1.1.2.tar.gz", hash = "sha256:0cf1f22e95b9002addca7948e16f2cd7acdfd498047f1941ca5d293db7762efd"},
@@ -4105,7 +4207,7 @@ description = "ISO 639 language codes, names, and other associated information"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "python_iso639-2024.10.22-py3-none-any.whl", hash = "sha256:02d3ce2e01c6896b30b9cbbd3e1c8ee0d7221250b5d63ea9803e0d2a81fd1047"},
     {file = "python_iso639-2024.10.22.tar.gz", hash = "sha256:750f21b6a0bc6baa24253a3d8aae92b582bf93aa40988361cd96852c2c6d9a52"},
@@ -4121,7 +4223,7 @@ description = "File type identification using libmagic"
 optional = true
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "python-magic-0.4.27.tar.gz", hash = "sha256:c1ba14b08e4a5f5c31a302b7721239695b2f0f058d125bd5ce1ee36b9d9d3c3b"},
     {file = "python_magic-0.4.27-py2.py3-none-any.whl", hash = "sha256:c212960ad306f700aa0d01e5d7a325d20548ff97eb9920dcd29513174f0294d3"},
@@ -4134,7 +4236,7 @@ description = "Generate and manipulate Open XML PowerPoint (.pptx) files"
 optional = true
 python-versions = "*"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "python-pptx-0.6.21.tar.gz", hash = "sha256:7798a2aaf89563565b3c7120c0acfe9aff775db0db3580544e3bf4840c2e378f"},
 ]
@@ -4151,7 +4253,7 @@ description = "Python library for the snappy compression library from Google"
 optional = true
 python-versions = "*"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "python_snappy-0.7.3-py3-none-any.whl", hash = "sha256:074c0636cfcd97e7251330f428064050ac81a52c62ed884fc2ddebbb60ed7f50"},
     {file = "python_snappy-0.7.3.tar.gz", hash = "sha256:40216c1badfb2d38ac781ecb162a1d0ec40f8ee9747e610bcfefdfa79486cee3"},
@@ -4167,6 +4269,7 @@ description = "Universally unique lexicographically sortable identifier"
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "python_ulid-3.0.0-py3-none-any.whl", hash = "sha256:e4c4942ff50dbd79167ad01ac725ec58f924b4018025ce22c858bfcff99a5e31"},
     {file = "python_ulid-3.0.0.tar.gz", hash = "sha256:e50296a47dc8209d28629a22fc81ca26c00982c78934bd7766377ba37ea49a9f"},
@@ -4182,6 +4285,7 @@ description = "World timezone definitions, modern and historical"
 optional = false
 python-versions = "*"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725"},
     {file = "pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a"},
@@ -4194,7 +4298,7 @@ description = "Python for Window Extensions"
 optional = false
 python-versions = "*"
 groups = ["dev"]
-markers = "platform_system == \"Windows\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and platform_system == \"Windows\""
 files = [
     {file = "pywin32-308-cp310-cp310-win32.whl", hash = "sha256:796ff4426437896550d2981b9c2ac0ffd75238ad9ea2d3bfa67a1abd546d262e"},
     {file = "pywin32-308-cp310-cp310-win_amd64.whl", hash = "sha256:4fc888c59b3c0bef905ce7eb7e2106a07712015ea1c8234b703a088d46110e8e"},
@@ -4223,6 +4327,7 @@ description = "YAML parser and emitter for Python"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086"},
     {file = "PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf"},
@@ -4286,6 +4391,7 @@ description = "rapid fuzzy string matching"
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "rapidfuzz-3.11.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:eb8a54543d16ab1b69e2c5ed96cabbff16db044a50eddfc028000138ca9ddf33"},
     {file = "rapidfuzz-3.11.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:231c8b2efbd7f8d2ecd1ae900363ba168b8870644bb8f2b5aa96e4a7573bde19"},
@@ -4387,6 +4493,7 @@ description = "Alternative regular expression module, to replace re."
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "regex-2024.11.6-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ff590880083d60acc0433f9c3f713c51f7ac6ebb9adf889c79a261ecf541aa91"},
     {file = "regex-2024.11.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:658f90550f38270639e83ce492f27d2c8d2cd63805c65a13a14d36ca126753f0"},
@@ -4491,6 +4598,7 @@ description = "Python HTTP for Humans."
 optional = false
 python-versions = ">=3.8"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"},
     {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"},
@@ -4513,6 +4621,7 @@ description = "A persistent cache for python requests"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "requests_cache-1.2.1-py3-none-any.whl", hash = "sha256:1285151cddf5331067baa82598afe2d47c7495a1334bfe7a7d329b43e9fd3603"},
     {file = "requests_cache-1.2.1.tar.gz", hash = "sha256:68abc986fdc5b8d0911318fbb5f7c80eebcd4d01bfacc6685ecf8876052511d1"},
@@ -4544,6 +4653,7 @@ description = "Mock out responses from the requests package"
 optional = false
 python-versions = ">=3.5"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "requests-mock-1.12.1.tar.gz", hash = "sha256:e9e12e333b525156e82a3c852f22016b9158220d2f47454de9cae8a77d371401"},
     {file = "requests_mock-1.12.1-py2.py3-none-any.whl", hash = "sha256:b1e37054004cdd5e56c84454cc7df12b25f90f382159087f4b6915aaeef39563"},
@@ -4562,6 +4672,7 @@ description = "A utility belt for advanced users of python-requests"
 optional = true
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6"},
     {file = "requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06"},
@@ -4577,6 +4688,7 @@ description = "This is a small Python module for parsing Pip requirement files."
 optional = false
 python-versions = "<4.0,>=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "requirements_parser-0.11.0-py3-none-any.whl", hash = "sha256:50379eb50311834386c2568263ae5225d7b9d0867fb55cf4ecc93959de2c2684"},
     {file = "requirements_parser-0.11.0.tar.gz", hash = "sha256:35f36dc969d14830bf459803da84f314dc3d17c802592e9e970f63d0359e5920"},
@@ -4593,6 +4705,7 @@ description = "Render rich text, tables, progress bars, syntax highlighting, mar
 optional = false
 python-versions = ">=3.8.0"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90"},
     {file = "rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098"},
@@ -4613,6 +4726,7 @@ description = "Format click help output nicely with rich"
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "rich_click-1.8.8-py3-none-any.whl", hash = "sha256:205aabd5a98e64ab2c105dee9e368be27480ba004c7dfa2accd0ed44f9f1550e"},
     {file = "rich_click-1.8.8.tar.gz", hash = "sha256:547c618dea916620af05d4a6456da797fbde904c97901f44d2f32f89d85d6c84"},
@@ -4634,6 +4748,7 @@ description = "Pure-Python RSA implementation"
 optional = false
 python-versions = "<4,>=3.6"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762"},
     {file = "rsa-4.9.1.tar.gz", hash = "sha256:e7bdbfdb5497da4c07dfd35530e1a902659db6ff241e39d9953cad06ebd0ae75"},
@@ -4649,6 +4764,7 @@ description = "An extremely fast Python linter and code formatter, written in Ru
 optional = false
 python-versions = ">=3.7"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "ruff-0.11.5-py3-none-linux_armv6l.whl", hash = "sha256:2561294e108eb648e50f210671cc56aee590fb6167b594144401532138c66c7b"},
     {file = "ruff-0.11.5-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ac12884b9e005c12d0bd121f56ccf8033e1614f736f766c118ad60780882a077"},
@@ -4677,7 +4793,7 @@ description = "A set of python modules for machine learning and data mining"
 optional = true
 python-versions = ">=3.9"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "scikit_learn-1.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d056391530ccd1e501056160e3c9673b4da4805eb67eb2bdf4e983e1f9c9204e"},
     {file = "scikit_learn-1.6.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:0c8d036eb937dbb568c6242fa598d551d88fb4399c0344d95c001980ec1c7d36"},
@@ -4733,7 +4849,7 @@ description = "Fundamental algorithms for scientific computing in Python"
 optional = true
 python-versions = ">=3.10"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "scipy-1.15.1-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:c64ded12dcab08afff9e805a67ff4480f5e69993310e093434b10e85dc9d43e1"},
     {file = "scipy-1.15.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:5b190b935e7db569960b48840e5bef71dc513314cc4e79a1b7d14664f57fd4ff"},
@@ -4783,7 +4899,20 @@ numpy = ">=1.23.5,<2.5"
 [package.extras]
 dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy (==1.10.0)", "pycodestyle", "pydevtool", "rich-click", "ruff (>=0.0.292)", "types-psutil", "typing_extensions"]
 doc = ["intersphinx_registry", "jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.16.5)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0,<8.0.0)", "sphinx-copybutton", "sphinx-design (>=0.4.0)"]
-test = ["Cython", "array-api-strict (>=2.0,<2.1.1)", "asv", "gmpy2", "hypothesis (>=6.30)", "meson", "mpmath", "ninja ; sys_platform != \"emscripten\"", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"]
+test = ["Cython", "array-api-strict (>=2.0,<2.1.1)", "asv", "gmpy2", "hypothesis (>=6.30)", "meson", "mpmath", "ninja", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"]
+
+[[package]]
+name = "semver"
+version = "3.0.4"
+description = "Python helper for Semantic Versioning (https://semver.org)"
+optional = false
+python-versions = ">=3.7"
+groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
+files = [
+    {file = "semver-3.0.4-py3-none-any.whl", hash = "sha256:9c824d87ba7f7ab4a1890799cec8596f15c1241cb473404ea1cb0c55e4b04746"},
+    {file = "semver-3.0.4.tar.gz", hash = "sha256:afc7d8c584a5ed0a11033af086e8af226a9c0b206f313e0301f8dd7b6b589602"},
+]
 
 [[package]]
 name = "serpyco-rs"
@@ -4792,6 +4921,7 @@ description = ""
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "serpyco_rs-1.13.0-cp310-cp310-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:e722b3053e627d8a304e462bce20cae1670a2c4b0ef875b84d0de0081bec4029"},
     {file = "serpyco_rs-1.13.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f10e89c752ff78d720a42e026b0a9ada70717ad6306a9356f794280167d62bf"},
@@ -4847,19 +4977,20 @@ description = "Easily download, build, install, upgrade, and uninstall Python pa
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "setuptools-76.0.0-py3-none-any.whl", hash = "sha256:199466a166ff664970d0ee145839f5582cb9bca7a0a3a2e795b6a9cb2308e9c6"},
     {file = "setuptools-76.0.0.tar.gz", hash = "sha256:43b4ee60e10b0d0ee98ad11918e114c70701bc6051662a9a675a0496c1a158f4"},
 ]
 
 [package.extras]
-check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\"", "ruff (>=0.8.0) ; sys_platform != \"cygwin\""]
-core = ["importlib_metadata (>=6) ; python_version < \"3.10\"", "jaraco.collections", "jaraco.functools (>=4)", "jaraco.text (>=3.7)", "more_itertools", "more_itertools (>=8.8)", "packaging", "packaging (>=24.2)", "platformdirs (>=4.2.2)", "tomli (>=2.0.1) ; python_version < \"3.11\"", "wheel (>=0.43.0)"]
+check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)", "ruff (>=0.8.0)"]
+core = ["importlib_metadata (>=6)", "jaraco.collections", "jaraco.functools (>=4)", "jaraco.text (>=3.7)", "more_itertools", "more_itertools (>=8.8)", "packaging", "packaging (>=24.2)", "platformdirs (>=4.2.2)", "tomli (>=2.0.1)", "wheel (>=0.43.0)"]
 cover = ["pytest-cov"]
 doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "pyproject-hooks (!=1.1)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier", "towncrier (<24.7)"]
 enabler = ["pytest-enabler (>=2.2)"]
-test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21) ; python_version >= \"3.9\" and sys_platform != \"cygwin\"", "jaraco.envs (>=2.2)", "jaraco.path (>=3.7.2)", "jaraco.test (>=5.5)", "packaging (>=24.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-home (>=0.5)", "pytest-perf ; sys_platform != \"cygwin\"", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel (>=0.44.0)"]
-type = ["importlib_metadata (>=7.0.2) ; python_version < \"3.10\"", "jaraco.develop (>=7.21) ; sys_platform != \"cygwin\"", "mypy (==1.14.*)", "pytest-mypy"]
+test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.7.2)", "jaraco.test (>=5.5)", "packaging (>=24.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-home (>=0.5)", "pytest-perf", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel (>=0.44.0)"]
+type = ["importlib_metadata (>=7.0.2)", "jaraco.develop (>=7.21)", "mypy (==1.14.*)", "pytest-mypy"]
 
 [[package]]
 name = "six"
@@ -4868,6 +4999,7 @@ description = "Python 2 and 3 compatibility utilities"
 optional = false
 python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274"},
     {file = "six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81"},
@@ -4880,6 +5012,7 @@ description = "Sniff out which async library your code is running under"
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"},
     {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"},
@@ -4892,7 +5025,7 @@ description = "A modern CSS selector implementation for Beautiful Soup."
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"},
     {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"},
@@ -4905,7 +5038,7 @@ description = "Database Abstraction Library"
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
-markers = "extra == \"vector-db-based\" or extra == \"sql\""
+markers = "(extra == \"vector-db-based\" or extra == \"sql\") and (python_version <= \"3.11\" or python_version >= \"3.12\")"
 files = [
     {file = "SQLAlchemy-2.0.37-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:da36c3b0e891808a7542c5c89f224520b9a16c7f5e4d6a1156955605e54aef0e"},
     {file = "SQLAlchemy-2.0.37-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e7402ff96e2b073a98ef6d6142796426d705addd27b9d26c3b32dbaa06d7d069"},
@@ -5002,7 +5135,7 @@ description = "Pretty-print tabular data"
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f"},
     {file = "tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c"},
@@ -5018,6 +5151,7 @@ description = "Retry code until it succeeds"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "tenacity-8.5.0-py3-none-any.whl", hash = "sha256:b594c2a5945830c267ce6b79a166228323ed52718f30302c1359836112346687"},
     {file = "tenacity-8.5.0.tar.gz", hash = "sha256:8bc6c0c8a09b31e6cad13c47afbed1a567518250a9a171418582ed8d9c20ca78"},
@@ -5034,6 +5168,7 @@ description = "Modern Text User Interface framework"
 optional = false
 python-versions = "<4.0.0,>=3.8.1"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "textual-1.0.0-py3-none-any.whl", hash = "sha256:2d4a701781c05104925e463ae370c630567c70c2880e92ab838052e3e23c986f"},
     {file = "textual-1.0.0.tar.gz", hash = "sha256:bec9fe63547c1c552569d1b75d309038b7d456c03f86dfa3706ddb099b151399"},
@@ -5046,7 +5181,7 @@ rich = ">=13.3.3"
 typing-extensions = ">=4.4.0,<5.0.0"
 
 [package.extras]
-syntax = ["tree-sitter (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-bash (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-css (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-go (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-html (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-java (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-javascript (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-json (>=0.24.0) ; python_version >= \"3.9\"", "tree-sitter-markdown (>=0.3.0) ; python_version >= \"3.9\"", "tree-sitter-python (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-regex (>=0.24.0) ; python_version >= \"3.9\"", "tree-sitter-rust (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-sql (>=0.3.0) ; python_version >= \"3.9\"", "tree-sitter-toml (>=0.6.0) ; python_version >= \"3.9\"", "tree-sitter-xml (>=0.7.0) ; python_version >= \"3.9\"", "tree-sitter-yaml (>=0.6.0) ; python_version >= \"3.9\""]
+syntax = ["tree-sitter (>=0.23.0)", "tree-sitter-bash (>=0.23.0)", "tree-sitter-css (>=0.23.0)", "tree-sitter-go (>=0.23.0)", "tree-sitter-html (>=0.23.0)", "tree-sitter-java (>=0.23.0)", "tree-sitter-javascript (>=0.23.0)", "tree-sitter-json (>=0.24.0)", "tree-sitter-markdown (>=0.3.0)", "tree-sitter-python (>=0.23.0)", "tree-sitter-regex (>=0.24.0)", "tree-sitter-rust (>=0.23.0)", "tree-sitter-sql (>=0.3.0)", "tree-sitter-toml (>=0.6.0)", "tree-sitter-xml (>=0.7.0)", "tree-sitter-yaml (>=0.6.0)"]
 
 [[package]]
 name = "threadpoolctl"
@@ -5055,7 +5190,7 @@ description = "threadpoolctl"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "threadpoolctl-3.5.0-py3-none-any.whl", hash = "sha256:56c1e26c150397e58c4926da8eeee87533b1e32bef131bd4bf6a2f45f3185467"},
     {file = "threadpoolctl-3.5.0.tar.gz", hash = "sha256:082433502dd922bf738de0d8bcc4fdcbf0979ff44c42bd40f5af8a282f6fa107"},
@@ -5068,7 +5203,7 @@ description = "tiktoken is a fast BPE tokeniser for use with OpenAI's models"
 optional = true
 python-versions = ">=3.9"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "tiktoken-0.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b07e33283463089c81ef1467180e3e00ab00d46c2c4bbcef0acab5f771d6695e"},
     {file = "tiktoken-0.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9269348cb650726f44dd3bbb3f9110ac19a8dcc8f54949ad3ef652ca22a38e21"},
@@ -5110,6 +5245,19 @@ requests = ">=2.26.0"
 [package.extras]
 blobfile = ["blobfile (>=2)"]
 
+[[package]]
+name = "toml"
+version = "0.10.2"
+description = "Python Library for Tom's Obvious, Minimal Language"
+optional = false
+python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
+groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
+files = [
+    {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"},
+    {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"},
+]
+
 [[package]]
 name = "tomli"
 version = "2.2.1"
@@ -5151,7 +5299,7 @@ files = [
     {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"},
     {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"},
 ]
-markers = {main = "python_version == \"3.10\""}
+markers = {main = "python_version < \"3.11\"", dev = "python_version <= \"3.11\" or python_version >= \"3.12\""}
 
 [[package]]
 name = "tqdm"
@@ -5160,6 +5308,7 @@ description = "Fast, Extensible Progress Meter"
 optional = true
 python-versions = ">=3.7"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2"},
     {file = "tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2"},
@@ -5182,6 +5331,7 @@ description = "Typing stubs for cachetools"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "types-cachetools-5.5.0.20240820.tar.gz", hash = "sha256:b888ab5c1a48116f7799cd5004b18474cd82b5463acb5ffb2db2fc9c7b053bc0"},
     {file = "types_cachetools-5.5.0.20240820-py3-none-any.whl", hash = "sha256:efb2ed8bf27a4b9d3ed70d33849f536362603a90b8090a328acf0cd42fda82e2"},
@@ -5194,6 +5344,7 @@ description = "Typing stubs for python-dateutil"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "types_python_dateutil-2.9.0.20241206-py3-none-any.whl", hash = "sha256:e248a4bc70a486d3e3ec84d0dc30eec3a5f979d6e7ee4123ae043eedbb987f53"},
     {file = "types_python_dateutil-2.9.0.20241206.tar.gz", hash = "sha256:18f493414c26ffba692a72369fea7a154c502646301ebfe3d56a04b3767284cb"},
@@ -5206,7 +5357,7 @@ description = "Typing stubs for pytz"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "types_pytz-2024.2.0.20241221-py3-none-any.whl", hash = "sha256:8fc03195329c43637ed4f593663df721fef919b60a969066e22606edf0b53ad5"},
     {file = "types_pytz-2024.2.0.20241221.tar.gz", hash = "sha256:06d7cde9613e9f7504766a0554a270c369434b50e00975b3a4a0f6eed0f2c1a9"},
@@ -5219,6 +5370,7 @@ description = "Typing stubs for PyYAML"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "types_PyYAML-6.0.12.20241230-py3-none-any.whl", hash = "sha256:fa4d32565219b68e6dee5f67534c722e53c00d1cfc09c435ef04d7353e1e96e6"},
     {file = "types_pyyaml-6.0.12.20241230.tar.gz", hash = "sha256:7f07622dbd34bb9c8b264fe860a17e0efcad00d50b5f27e93984909d9363498c"},
@@ -5231,6 +5383,7 @@ description = "Typing stubs for requests"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "types-requests-2.32.0.20241016.tar.gz", hash = "sha256:0d9cad2f27515d0e3e3da7134a1b6f28fb97129d86b867f24d9c726452634d95"},
     {file = "types_requests-2.32.0.20241016-py3-none-any.whl", hash = "sha256:4195d62d6d3e043a4eaaf08ff8a62184584d2e8684e9d2aa178c7915a7da3747"},
@@ -5246,6 +5399,7 @@ description = "Typing stubs for setuptools"
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "types_setuptools-75.8.2.20250305-py3-none-any.whl", hash = "sha256:ba80953fd1f5f49e552285c024f75b5223096a38a5138a54d18ddd3fa8f6a2d4"},
     {file = "types_setuptools-75.8.2.20250305.tar.gz", hash = "sha256:a987269b49488f21961a1d99aa8d281b611625883def6392a93855b31544e405"},
@@ -5254,6 +5408,19 @@ files = [
 [package.dependencies]
 setuptools = "*"
 
+[[package]]
+name = "types-toml"
+version = "0.10.8.20240310"
+description = "Typing stubs for toml"
+optional = false
+python-versions = ">=3.8"
+groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
+files = [
+    {file = "types-toml-0.10.8.20240310.tar.gz", hash = "sha256:3d41501302972436a6b8b239c850b26689657e25281b48ff0ec06345b8830331"},
+    {file = "types_toml-0.10.8.20240310-py3-none-any.whl", hash = "sha256:627b47775d25fa29977d9c70dc0cbab3f314f32c8d8d0c012f2ef5de7aaec05d"},
+]
+
 [[package]]
 name = "typing-extensions"
 version = "4.12.2"
@@ -5261,6 +5428,7 @@ description = "Backported and Experimental Type Hints for Python 3.8+"
 optional = false
 python-versions = ">=3.8"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"},
     {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"},
@@ -5273,7 +5441,7 @@ description = "Runtime inspection utilities for typing module."
 optional = true
 python-versions = "*"
 groups = ["main"]
-markers = "extra == \"vector-db-based\" or extra == \"file-based\""
+markers = "(extra == \"vector-db-based\" or extra == \"file-based\") and (python_version <= \"3.11\" or python_version >= \"3.12\")"
 files = [
     {file = "typing_inspect-0.9.0-py3-none-any.whl", hash = "sha256:9ee6fc59062311ef8547596ab6b955e1b8aa46242d854bfc78f4f6b0eff35f9f"},
     {file = "typing_inspect-0.9.0.tar.gz", hash = "sha256:b23fc42ff6f6ef6954e4852c1fb512cdd18dbea03134f91f856a95ccc9461f78"},
@@ -5290,6 +5458,7 @@ description = "Provider of IANA time zone data"
 optional = false
 python-versions = ">=2"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "tzdata-2025.1-py2.py3-none-any.whl", hash = "sha256:7e127113816800496f027041c570f50bcd464a020098a3b6b199517772303639"},
     {file = "tzdata-2025.1.tar.gz", hash = "sha256:24894909e88cdb28bd1636c6887801df64cb485bd593f2fd83ef29075a81d694"},
@@ -5302,6 +5471,7 @@ description = "Micro subset of unicode data files for linkify-it-py projects."
 optional = false
 python-versions = ">=3.7"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a"},
     {file = "uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5"},
@@ -5317,7 +5487,7 @@ description = "A library that prepares raw documents for downstream ML tasks."
 optional = true
 python-versions = ">=3.7.0"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "unstructured-0.10.27-py3-none-any.whl", hash = "sha256:3a8a8e44302388ddc39c184059e8b4458f1cdc58032540b9af7d85f6c3eca3be"},
     {file = "unstructured-0.10.27.tar.gz", hash = "sha256:f567b5c4385993a9ab48db5563dd7b413aac4f2002bb22e6250496ea8f440f5e"},
@@ -5399,7 +5569,7 @@ description = "Python-tesseract is a python wrapper for Google's Tesseract-OCR"
 optional = true
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "unstructured.pytesseract-0.3.13-py3-none-any.whl", hash = "sha256:8001bc860470d56185176eb3ceb4623e888eba058ca3b30af79003784bc40e19"},
     {file = "unstructured.pytesseract-0.3.13.tar.gz", hash = "sha256:ff2e6391496e457dbf4b4e327f4a4577cce18921ea6570dc74bd64381b10e963"},
@@ -5416,6 +5586,7 @@ description = "URL normalization for Python"
 optional = false
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "url-normalize-1.4.3.tar.gz", hash = "sha256:d23d3a070ac52a67b83a1c59a0e68f8608d1cd538783b401bc9de2c0fac999b2"},
     {file = "url_normalize-1.4.3-py2.py3-none-any.whl", hash = "sha256:ec3c301f04e5bb676d333a7fa162fa977ad2ca04b7e652bfc9fac4e405728eed"},
@@ -5431,13 +5602,14 @@ description = "HTTP library with thread-safe connection pooling, file post, and
 optional = false
 python-versions = ">=3.9"
 groups = ["main", "dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df"},
     {file = "urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d"},
 ]
 
 [package.extras]
-brotli = ["brotli (>=1.0.9) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=0.8.0) ; platform_python_implementation != \"CPython\""]
+brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"]
 h2 = ["h2 (>=4,<5)"]
 socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
 zstd = ["zstandard (>=0.18.0)"]
@@ -5449,6 +5621,7 @@ description = "Wildcard/glob file name matcher."
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "wcmatch-10.0-py3-none-any.whl", hash = "sha256:0dd927072d03c0a6527a20d2e6ad5ba8d0380e60870c383bc533b71744df7b7a"},
     {file = "wcmatch-10.0.tar.gz", hash = "sha256:e72f0de09bba6a04e0de70937b0cf06e55f36f37b3deb422dfaf854b867b840a"},
@@ -5464,6 +5637,7 @@ description = "The comprehensive WSGI web application library."
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "werkzeug-3.1.3-py3-none-any.whl", hash = "sha256:54b78bf3716d19a65be4fceccc0d1d7b89e608834989dfae50ea87564639213e"},
     {file = "werkzeug-3.1.3.tar.gz", hash = "sha256:60723ce945c19328679790e3282cc758aa4a6040e4bb330f53d30fa546d44746"},
@@ -5482,6 +5656,7 @@ description = "Modern datetime library for Python"
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "whenever-0.6.16-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:901783ba877b5d73ce5b1bc1697c6097a9ac14c43064788b24ec7dc75a85a90a"},
     {file = "whenever-0.6.16-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4d374cd750ea68adb4ad69d52aef3838eda38ae63183c6135b122772ac053c66"},
@@ -5566,7 +5741,7 @@ description = "A Python module for creating Excel XLSX files."
 optional = true
 python-versions = ">=3.6"
 groups = ["main"]
-markers = "extra == \"file-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"file-based\""
 files = [
     {file = "XlsxWriter-3.2.0-py3-none-any.whl", hash = "sha256:ecfd5405b3e0e228219bcaf24c2ca0915e012ca9464a14048021d21a995d490e"},
     {file = "XlsxWriter-3.2.0.tar.gz", hash = "sha256:9977d0c661a72866a61f9f7a809e25ebbb0fb7036baa3b9fe74afcfca6b3cb8c"},
@@ -5579,6 +5754,7 @@ description = "Makes working with XML feel like you are working with JSON"
 optional = false
 python-versions = ">=3.6"
 groups = ["main"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "xmltodict-0.14.2-py2.py3-none-any.whl", hash = "sha256:20cc7d723ed729276e808f26fb6b3599f786cbc37e06c65e192ba77c40f20aac"},
     {file = "xmltodict-0.14.2.tar.gz", hash = "sha256:201e7c28bb210e374999d1dde6382923ab0ed1a8a5faeece48ab525b7810a553"},
@@ -5591,7 +5767,7 @@ description = "Yet another URL library"
 optional = true
 python-versions = ">=3.9"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "yarl-1.18.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7df647e8edd71f000a5208fe6ff8c382a1de8edfbccdbbfe649d263de07d8c34"},
     {file = "yarl-1.18.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c69697d3adff5aa4f874b19c0e4ed65180ceed6318ec856ebc423aa5850d84f7"},
@@ -5689,18 +5865,18 @@ description = "Backport of pathlib-compatible object wrapper for zip files"
 optional = true
 python-versions = ">=3.9"
 groups = ["main"]
-markers = "extra == \"vector-db-based\""
+markers = "(python_version <= \"3.11\" or python_version >= \"3.12\") and extra == \"vector-db-based\""
 files = [
     {file = "zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931"},
     {file = "zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4"},
 ]
 
 [package.extras]
-check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""]
+check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"]
 cover = ["pytest-cov"]
 doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
 enabler = ["pytest-enabler (>=2.2)"]
-test = ["big-O", "importlib-resources ; python_version < \"3.9\"", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-ignore-flaky"]
+test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-ignore-flaky"]
 type = ["pytest-mypy"]
 
 [extras]
@@ -5712,4 +5888,4 @@ vector-db-based = ["cohere", "langchain", "openai", "tiktoken"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.10,<3.13"
-content-hash = "3462b02e03e9f7edd9dec23acde60ad4f7128ace08ce1787556aa0b4bcd25a86"
+content-hash = "dbbcdb5aa40b3e0e5e506fa80cdf1c2a0b63756fbc55199640ad6e65170b4e9e"
diff --git a/pyproject.toml b/pyproject.toml
index 74d2f6d56..a20a12f80 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -35,6 +35,8 @@ airbyte-protocol-models-dataclasses = "^0.15"
 backoff = "*"
 boltons = "^25.0.0"
 cachetools = "*"
+semver = "^3.0.0"
+pydash = "^7.0.0"
 click = "^8.1.8"
 dpath = "^2.1.6"
 dunamai = "^1.22.0"
@@ -90,6 +92,7 @@ sqlalchemy = {version = "^2.0,!=2.0.36", optional = true }
 xmltodict = ">=0.13,<0.15"
 anyascii = "^0.3.2"
 whenever = "^0.6.16"
+toml = "^0.10.2"
 
 [tool.poetry.group.dev.dependencies]
 freezegun = "*"
@@ -112,6 +115,7 @@ types-python-dateutil = "^2.9.0.20241003"
 types-pyyaml = "^6.0.12.20240917"
 types-cachetools = "^5.5.0.20240820"
 deptry = "^0.23.0"
+types-toml = "^0.10.8.20240310"
 
 [tool.poetry.extras]
 file-based = ["avro", "fastavro", "pyarrow", "unstructured", "pdf2image", "pdfminer.six", "unstructured.pytesseract", "pytesseract", "markdown", "python-calamine", "python-snappy"]
diff --git a/tests/qa/test_connector.py b/tests/qa/test_connector.py
new file mode 100644
index 000000000..2c7a19dd7
--- /dev/null
+++ b/tests/qa/test_connector.py
@@ -0,0 +1,159 @@
+"""Tests for the Connector class."""
+
+import os
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+import yaml
+
+from airbyte_cdk.qa.connector import Connector, ConnectorLanguage
+
+
+class TestConnector:
+    """Tests for the Connector class."""
+
+    def test_technical_name(self):
+        """Test the technical_name property."""
+        connector = Connector("source-test")
+        assert connector.technical_name == "source-test"
+
+    def test_name(self):
+        """Test the name property."""
+        connector = Connector("source-test")
+        assert connector.name == "source-test"
+
+    def test_connector_type(self):
+        """Test the connector_type property."""
+        connector = Connector("source-test")
+        assert connector.connector_type == "source"
+        connector = Connector("destination-test")
+        assert connector.connector_type == "destination"
+
+    def test_code_directory(self):
+        """Test the code_directory property."""
+        connector = Connector("source-test", Path("/path/to/connector"))
+        assert connector.code_directory == Path("/path/to/connector")
+
+    def test_metadata_file_path(self):
+        """Test the metadata_file_path property."""
+        connector = Connector("source-test", Path("/path/to/connector"))
+        assert connector.metadata_file_path == Path("/path/to/connector/metadata.yaml")
+
+    @patch("airbyte_cdk.qa.connector.yaml.safe_load")
+    def test_metadata(self, mock_safe_load):
+        """Test the metadata property."""
+        mock_metadata = {"data": {"name": "Test Connector"}}
+        mock_safe_load.return_value = mock_metadata
+        
+        with patch("builtins.open", MagicMock()):
+            with patch("pathlib.Path.exists", return_value=True):
+                connector = Connector("source-test", Path("/path/to/connector"))
+                assert connector.metadata == mock_metadata
+                assert connector.metadata == mock_metadata
+                mock_safe_load.assert_called_once()
+
+    def test_metadata_file_not_exists(self):
+        """Test the metadata property when the metadata file doesn't exist."""
+        with patch("pathlib.Path.exists", return_value=False):
+            connector = Connector("source-test", Path("/path/to/connector"))
+            assert connector.metadata is None
+
+    def test_language_python(self):
+        """Test the language property for Python connectors."""
+        with patch("pathlib.Path.exists", side_effect=lambda p: p.name == "pyproject.toml"):
+            connector = Connector("source-test", Path("/path/to/connector"))
+            assert connector.language == ConnectorLanguage.PYTHON
+
+    def test_language_java(self):
+        """Test the language property for Java connectors."""
+        with patch("pathlib.Path.exists", side_effect=lambda p: "src/main/java" in str(p)):
+            connector = Connector("source-test", Path("/path/to/connector"))
+            assert connector.language == ConnectorLanguage.JAVA
+
+    def test_language_low_code(self):
+        """Test the language property for low-code connectors."""
+        with patch("pathlib.Path.exists", side_effect=lambda p: p.name == "manifest.yaml"):
+            connector = Connector("source-test", Path("/path/to/connector"))
+            assert connector.language == ConnectorLanguage.LOW_CODE
+
+    def test_language_unknown(self):
+        """Test the language property for unknown connectors."""
+        with patch("pathlib.Path.exists", return_value=False):
+            connector = Connector("source-test", Path("/path/to/connector"))
+            assert connector.language is None
+
+    def test_manifest_path(self):
+        """Test the manifest_path property."""
+        connector = Connector("source-test", Path("/path/to/connector"))
+        assert connector.manifest_path == Path("/path/to/connector/manifest.yaml")
+
+    @patch("airbyte_cdk.qa.connector.Connector.metadata", new_callable=MagicMock)
+    def test_version(self, mock_metadata):
+        """Test the version property."""
+        mock_metadata.get.return_value = {"data": {"dockerImageTag": "1.0.0"}}
+        connector = Connector("source-test", Path("/path/to/connector"))
+        assert connector.version == "1.0.0"
+
+    def test_version_in_dockerfile_label(self):
+        """Test the version_in_dockerfile_label property."""
+        dockerfile_content = 'FROM python:3.9\nLABEL io.airbyte.version="1.0.0"\n'
+        with patch("builtins.open", MagicMock(return_value=MagicMock(read=MagicMock(return_value=dockerfile_content)))):
+            with patch("pathlib.Path.exists", return_value=True):
+                connector = Connector("source-test", Path("/path/to/connector"))
+                assert connector.version_in_dockerfile_label == "1.0.0"
+
+    def test_version_in_dockerfile_label_no_dockerfile(self):
+        """Test the version_in_dockerfile_label property when the Dockerfile doesn't exist."""
+        with patch("pathlib.Path.exists", return_value=False):
+            connector = Connector("source-test", Path("/path/to/connector"))
+            assert connector.version_in_dockerfile_label is None
+
+    @patch("airbyte_cdk.qa.connector.Connector.metadata", new_callable=MagicMock)
+    def test_name_from_metadata(self, mock_metadata):
+        """Test the name_from_metadata property."""
+        mock_metadata.get.return_value = {"data": {"name": "Test Connector"}}
+        connector = Connector("source-test", Path("/path/to/connector"))
+        assert connector.name_from_metadata == "Test Connector"
+
+    @patch("airbyte_cdk.qa.connector.Connector.metadata", new_callable=MagicMock)
+    def test_support_level(self, mock_metadata):
+        """Test the support_level property."""
+        mock_metadata.get.return_value = {"data": {"supportLevel": "certified"}}
+        connector = Connector("source-test", Path("/path/to/connector"))
+        assert connector.support_level == "certified"
+
+    @patch("airbyte_cdk.qa.connector.Connector.metadata", new_callable=MagicMock)
+    def test_cloud_usage(self, mock_metadata):
+        """Test the cloud_usage property."""
+        mock_metadata.get.return_value = {"data": {"cloudUsage": "enabled"}}
+        connector = Connector("source-test", Path("/path/to/connector"))
+        assert connector.cloud_usage == "enabled"
+
+    @patch("airbyte_cdk.qa.connector.Connector.metadata", new_callable=MagicMock)
+    def test_ab_internal_sl(self, mock_metadata):
+        """Test the ab_internal_sl property."""
+        mock_metadata.get.return_value = {"data": {"ab_internal": {"sl": 200}}}
+        connector = Connector("source-test", Path("/path/to/connector"))
+        assert connector.ab_internal_sl == 200
+
+    def test_is_released(self):
+        """Test the is_released property."""
+        connector = Connector("source-test", Path("/path/to/connector"))
+        assert connector.is_released is True
+
+    def test_pyproject_file_path(self):
+        """Test the pyproject_file_path property."""
+        connector = Connector("source-test", Path("/path/to/connector"))
+        assert connector.pyproject_file_path == Path("/path/to/connector/pyproject.toml")
+
+    def test_dockerfile_file_path(self):
+        """Test the dockerfile_file_path property."""
+        connector = Connector("source-test", Path("/path/to/connector"))
+        assert connector.dockerfile_file_path == Path("/path/to/connector/Dockerfile")
+
+    def test_has_dockerfile(self):
+        """Test the has_dockerfile property."""
+        with patch("pathlib.Path.exists", return_value=True):
+            connector = Connector("source-test", Path("/path/to/connector"))
+            assert connector.has_dockerfile is True
diff --git a/tests/qa/test_models.py b/tests/qa/test_models.py
new file mode 100644
index 000000000..1580baf5d
--- /dev/null
+++ b/tests/qa/test_models.py
@@ -0,0 +1,80 @@
+"""Tests for the QA models."""
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from airbyte_cdk.qa.connector import Connector, ConnectorLanguage
+from airbyte_cdk.qa.models import Check, CheckCategory, CheckResult, CheckStatus, Report
+
+
+class TestCheck(Check):
+    """Test implementation of the Check abstract class."""
+
+    name = "Test Check"
+    description = "Test check description"
+    category = CheckCategory.TESTING
+
+    def _run(self, connector: Connector) -> CheckResult:
+        """Run the check.
+
+        Args:
+            connector: The connector to check
+
+        Returns:
+            CheckResult: The result of the check
+        """
+        return self.pass_(connector, "Test passed")
+
+
+class TestCheckResult:
+    """Tests for the CheckResult class."""
+
+    def test_repr(self):
+        """Test the __repr__ method."""
+        connector = MagicMock()
+        connector.__repr__.return_value = "test-connector"
+        check = TestCheck()
+        result = CheckResult(check=check, connector=connector, status=CheckStatus.PASSED, message="Test passed")
+        assert repr(result) == "test-connector - ✅ Passed - Test Check: Test passed."
+
+
+class TestReport:
+    """Tests for the Report class."""
+
+    def test_to_json(self):
+        """Test the to_json method."""
+        connector = MagicMock()
+        connector.technical_name = "test-connector"
+        check = TestCheck()
+        result = CheckResult(check=check, connector=connector, status=CheckStatus.PASSED, message="Test passed")
+        report = Report(check_results=[result])
+        json_report = report.to_json()
+        data = json.loads(json_report)
+        assert "generation_timestamp" in data
+        assert "connectors" in data
+        assert "test-connector" in data["connectors"]
+        assert data["connectors"]["test-connector"]["successful_checks_count"] == 1
+        assert data["connectors"]["test-connector"]["total_checks_count"] == 1
+        assert data["connectors"]["test-connector"]["failed_checks_count"] == 0
+        assert data["connectors"]["test-connector"]["skipped_checks_count"] == 0
+        assert len(data["connectors"]["test-connector"]["passed_checks"]) == 1
+        assert data["connectors"]["test-connector"]["passed_checks"][0]["check"] == "Test Check"
+        assert data["connectors"]["test-connector"]["passed_checks"][0]["message"] == "Test passed"
+
+    def test_write(self, tmp_path):
+        """Test the write method."""
+        connector = MagicMock()
+        connector.technical_name = "test-connector"
+        check = TestCheck()
+        result = CheckResult(check=check, connector=connector, status=CheckStatus.PASSED, message="Test passed")
+        report = Report(check_results=[result])
+        report_path = tmp_path / "report.json"
+        report.write(report_path)
+        assert report_path.exists()
+        data = json.loads(report_path.read_text())
+        assert "generation_timestamp" in data
+        assert "connectors" in data
+        assert "test-connector" in data["connectors"]