querent


Namequerent JSON
Version 3.1.2 PyPI version JSON
download
home_pagehttps://github.com/Querent-ai/querent-ai
SummaryThe Asynchronous Data Dynamo and Graph Neural Network Catalyst
upload_time2024-06-10 11:13:54
maintainerNone
docs_urlNone
authorQuerent AI
requires_python<3.11,>=3.10
licenseBusiness Source License 1.1
keywords graph neural network scalability data-driven insights gnn async knowledge graphs kg large language models asyncio insights aysnchronous llm transformers pytorch llama-index ai artificial intelligence neo4j queues quiassisstant collectors data data science data engineering data analysis data analytics news nlp natural language processing text text analysis deep learning graphs graph theory graph algorithms graph analytics graph databases graph processing graph mining graph neural networks gnn gnns graph neural network
VCS
bugtrack_url
requirements No requirements were recorded.
Travis-CI No Travis.
coveralls test coverage No coveralls.
            # Querent

The Asynchronous Data Dynamo and Graph Neural Network Catalyst

![image](https://github.com/Querent-ai/querent-ai/assets/61435908/39124a0c-3d9e-434f-9b54-9aa51dcefbd7)



## Unlock Insights, Asynchronous Scaling, and Forge a Knowledge-Driven Future

🚀 **Async at its Core**: Querent thrives in an asynchronous world. With asynchronous processing, we handle multiple data sources seamlessly, eliminating bottlenecks for utmost efficiency.

💡 **Knowledge Graphs Made Easy**: Constructing intricate knowledge graphs is a breeze. Querent's robust architecture simplifies building comprehensive knowledge graphs, enabling you to uncover hidden data relationships.

🌐 **Scalability Redefined**: Scaling your data operations is effortless with Querent. We scale horizontally, empowering you to process multiple data streams without breaking a sweat.

🔬 **GNN Integration**: Querent seamlessly integrates with Graph Neural Networks (GNNs), enabling advanced data analysis, recommendation systems, and predictive modeling.

🔍 **Data-Driven Insights**: Dive deep into data-driven insights with Querent's tools. Extract actionable information and make data-informed decisions with ease.

🧠 **Leverage Language Models**: Utilize state-of-the-art language models (LLMs) for text data. Querent empowers natural language processing, tackling complex text-based tasks.

📈 **Efficient Memory Usage**: Querent is mindful of memory constraints. Our framework uses memory-efficient techniques, ensuring you can handle large datasets economically.

## Table of Contents

- [Querent](#querent)
  - [Unlock Insights, Asynchronous Scaling, and Forge a Knowledge-Driven Future](#unlock-insights-asynchronous-scaling-and-forge-a-knowledge-driven-future)
  - [Table of Contents](#table-of-contents)
  - [Introduction](#introduction)
  - [Features](#features)
  - [Getting Started](#getting-started)
    - [Prerequisites](#prerequisites)
    - [Installation](#installation)
  - [Usage](#usage)
  - [Configuration](#configuration)
  - [Querent: an asynchronous engine for LLMs](#querent-an-asynchronous-engine-for-llms)
  - [Ease of Use](#ease-of-use)
  - [Contributing](#contributing)
  - [License](#license)

## Introduction

Querent is designed to simplify and optimize data collection and processing workflows. Whether you need to scrape web data, ingest files, preprocess text, or create complex knowledge graphs, Querent offers a flexible framework for building and scaling these processes.

## Features

- **Collectors:** Gather data from various sources asynchronously, including web scraping and file collection.

- **Ingestors:** Process collected data efficiently with custom transformations and filtering.

- **Processors:** Apply asynchronous data processing, including text preprocessing, cleaning, and feature extraction.

- **Engines:** Execute a suite of LLM engines to extract insights from data, leveraging parallel processing for enhanced efficiency.

- **Storage:** Store processed data in various storage systems, such as databases or cloud storage.

- **Workflow Management:** Efficiently manage and scale data workflows with task orchestration.

- **Scalability:** Querent is designed to scale horizontally, handling large volumes of data with ease.

## Getting Started

Let's get Querent up and running on your local machine.

### Prerequisites

- Python 3.9+
- Virtual environment (optional but recommended)

### Installation

1. Create a virtual environment (recommended):

   ```bash
   python -m venv venv
   source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
   ```
2. Install latest Querent Workflow Orchestrator package:

   ```bash
   pip install querent
   ```
  
3. Install the project dependencies:

   ```bash
     python3 -m spacy download en_core_web_lg
   ```

4. Apt install the project dependencies:
   ```bash
        sudo apt install tesseract-ocr
        sudo apt install libtesseract-dev
        sudo apt-get install ffmpeg
        sudo apt install antiword
    ```

## Usage

Querent provides a flexible framework that adapts to your specific data collection and processing needs. Here's how to get started:

1. **Configuration:** Set up collector, ingestor, and processor configurations as needed.

2. **Collecting Data:** Implement collector classes to gather data from chosen sources. Handle errors and edge cases gracefully.

3. **Processing Data:** Create ingestors and processors to clean, transform, and filter collected data. Apply custom logic to meet your requirements.

4. **Storage:** Choose your storage system (e.g., databases) and configure connections. Store processed data efficiently.

5. **Task Orchestration:** For large tasks, implement a task orchestrator to manage and distribute the workload.

6. **Scaling:** To handle scalability, consider running multiple instances of collectors and ingestors in parallel.

7. **Monitoring:** Implement monitoring and logging to track task progress, detect errors, and ensure smooth operation.

8. **Documentation:** Maintain thorough project documentation to make it easy for others (and yourself) to understand and contribute.

## Configuration

Querent relies on configuration files to define how collectors, ingestors, and processors operate. These files are typically located in the `config` directory. Ensure that you configure the components according to your project's requirements.

## Querent: an asynchronous engine for LLMs

**Sequence Diagram:** *Asynchronous Data Processing in Querent*

```mermaid
sequenceDiagram
    participant User
    participant Collector
    participant Ingestor
    participant Processor
    participant LLM
    participant Querent
    participant Storage
    participant Callback

    User->>Collector: Initiate Data Collection
    Collector->>Ingestor: Collect Data
    Ingestor->>Processor: Ingest Data
    Processor->>LLM: Process Data (IngestedTokens)
    LLM->>Processor: Processed Data (EventState)
    Processor->>Storage: Store Processed Data (CollectedBytes)
    Ingestor->>Querent: Send Ingested Data (IngestedTokens)
    Querent->>Processor: Process Ingested Data (IngestedTokens)
    Processor->>LLM: Process Data (IngestedTokens)
    LLM->>Processor: Processed Data (EventState)
    Callback->>Storage: Store Processed Data (EventState)
    Querent->>Processor: Processed Data Available (EventState)
    Processor->>Callback: Return Processed Data (EventState)
    Callback->>User: Deliver Processed Data (CollectedBytes)

    Note right of User: Asynchronous Flow
    Note right of Collector: Data Collection
    Note right of Ingestor: Data Ingestion
    Note right of Processor: Data Processing
    Note right of LLM: Language Model Processing
    Note right of Querent: Query Execution
    Note right of Storage: Data Storage
    Note right of Callback: Callback Invocation

```

## Ease of Use

With Querent, creating scalable workflows with any LLM is just a few lines of code.

```python
import pytest
import uuid
from pathlib import Path
import asyncio

from querent.callback.event_callback_interface import EventCallbackInterface
from querent.common.types.ingested_tokens import IngestedTokens
from querent.common.types.ingested_code import IngestedCode
from querent.common.types.ingested_images import IngestedImages
from querent.common.types.ingested_messages import IngestedMessages
from querent.common.types.querent_event import EventState, EventType
from querent.common.types.querent_queue import QuerentQueue
from querent.core.base_engine import BaseEngine
from querent.querent.querent import Querent
from querent.querent.resource_manager import ResourceManager
from querent.collectors.collector_resolver import CollectorResolver
from querent.common.uri import Uri
from querent.config.collector.collector_config import FSCollectorConfig
from querent.ingestors.ingestor_manager import IngestorFactoryManager

# Create input and output queues
input_queue = QuerentQueue()
resource_manager = ResourceManager()


# Define a simple mock LLM engine for testing
class MockLLMEngine(BaseEngine):
    def __init__(self, input_queue: QuerentQueue):
        super().__init__(input_queue)

    async def process_tokens(self, data: IngestedTokens):
        if data is None or data.is_error():
            # the LLM developer can raise an error here or do something else
            # the developers of Querent can customize the behavior of Querent
            # to handle the error in a way that is appropriate for the use case
            self.set_termination_event()
            return
        # Set the state of the LLM
        # At any given point during the execution of the LLM, the LLM developer
        # can set the state of the LLM using the set_state method
        # The state of the LLM is stored in the state attribute of the LLM
        # The state of the LLM is published to subscribers of the LLM
        current_state = EventState(EventType.Graph, 1.0, "anything", "dummy.txt")
        await self.set_state(new_state=current_state)

    async def process_code(self, data: IngestedCode):
        pass

    async def process_messages(self, data: IngestedMessages):
        return super().process_messages(data)

    async def process_images(self, data: IngestedImages):
        return super().process_images(data)

    def validate(self):
        return True


@pytest.mark.asyncio
async def test_example_workflow_with_querent():
    # Initialize some collectors to collect the data
    directory_path = "path/to/your/data/directory"
    collectors = [
        CollectorResolver().resolve(
            Uri("file://" + str(Path(directory_path).resolve())),
            FSCollectorConfig(root_path=directory_path, id=str(uuid.uuid4())),
        )
    ]

    # Connect to the collector
    for collector in collectors:
        await collector.connect()

    # Set up the result queue
    result_queue = asyncio.Queue()

    # Create the IngestorFactoryManager
    ingestor_factory_manager = IngestorFactoryManager(
        collectors=collectors, result_queue=result_queue
    )

    # Start the ingest_all_async in a separate task
    ingest_task = asyncio.create_task(ingestor_factory_manager.ingest_all_async())

    ### A Typical Use Case ###
    # Create an engine to harness the LLM
    llm_mocker = MockLLMEngine(input_queue)

    # Define a callback function to subscribe to state changes
    class StateChangeCallback(EventCallbackInterface):
        async def handle_event(self, event_type: EventType, event_state: EventState):
            print(f"New state: {event_state}")
            print(f"New state type: {event_type}")
            assert event_state.event_type == EventType.Graph

    # Subscribe to state change events
    # This pattern is ideal as we can expose multiple events for each use case of the LLM
    llm_mocker.subscribe(EventType.Graph, StateChangeCallback())

    ## one can also subscribe to other events, e.g. EventType.CHAT_COMPLETION ...

    # Create a Querent instance with a single MockLLM
    # here we see the simplicity of the Querent
    # massive complexity is hidden in the Querent,
    # while being highly configurable, extensible, and scalable
    # async architecture helps to scale to multiple querenters
    # How async architecture works:
    #   1. Querent starts a worker task for each querenter
    #   2. Querenter starts a worker task for each worker
    #   3. Each worker task runs in a loop, waiting for input data
    #   4. When input data is received, the worker task processes the data
    #   5. The worker task notifies subscribers of state changes
    #   6. The worker task repeats steps 3-5 until termination
    querent = Querent(
        [llm_mocker],
        resource_manager=resource_manager,
    )
    # Start the querent
    querent_task = asyncio.create_task(querent.start())
    await asyncio.gather(ingest_task, querent_task)


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


```

## Contributing

Contributions to Querent are welcome! Please follow our [contribution guidelines](CONTRIBUTING.md) to get started.

## License

This project is licensed under the BSL-1.1 License - see the [LICENSE](LICENCE) file for details.

            

Raw data

            {
    "_id": null,
    "home_page": "https://github.com/Querent-ai/querent-ai",
    "name": "querent",
    "maintainer": null,
    "docs_url": null,
    "requires_python": "<3.11,>=3.10",
    "maintainer_email": null,
    "keywords": "Graph Neural Network, Scalability, Data-Driven Insights, GNN, Async, Knowledge Graphs, KG, Large Language Models, asyncio, Insights, aysnchronous, LLM, transformers, pytorch, Llama-index, AI, Artificial Intelligence, Neo4j, Queues, QuiAssisstant, Collectors, Data, Data Science, Data Engineering, Data Analysis, Data Analytics, News, NLP, Natural Language Processing, Text, Text Analysis, Deep Learning, Graphs, Graph Theory, Graph Algorithms, Graph Analytics, Graph Databases, Graph Processing, Graph Mining, Graph Neural Networks, GNN, GNNs, Graph Neural Network",
    "author": "Querent AI",
    "author_email": null,
    "download_url": "https://files.pythonhosted.org/packages/cc/1d/dbc54045c170f9383ee186e8de7c4a291a1d105201df84cbee44d4630b5d/querent-3.1.2.tar.gz",
    "platform": null,
    "description": "# Querent\n\nThe Asynchronous Data Dynamo and Graph Neural Network Catalyst\n\n![image](https://github.com/Querent-ai/querent-ai/assets/61435908/39124a0c-3d9e-434f-9b54-9aa51dcefbd7)\n\n\n\n## Unlock Insights, Asynchronous Scaling, and Forge a Knowledge-Driven Future\n\n\ud83d\ude80 **Async at its Core**: Querent thrives in an asynchronous world. With asynchronous processing, we handle multiple data sources seamlessly, eliminating bottlenecks for utmost efficiency.\n\n\ud83d\udca1 **Knowledge Graphs Made Easy**: Constructing intricate knowledge graphs is a breeze. Querent's robust architecture simplifies building comprehensive knowledge graphs, enabling you to uncover hidden data relationships.\n\n\ud83c\udf10 **Scalability Redefined**: Scaling your data operations is effortless with Querent. We scale horizontally, empowering you to process multiple data streams without breaking a sweat.\n\n\ud83d\udd2c **GNN Integration**: Querent seamlessly integrates with Graph Neural Networks (GNNs), enabling advanced data analysis, recommendation systems, and predictive modeling.\n\n\ud83d\udd0d **Data-Driven Insights**: Dive deep into data-driven insights with Querent's tools. Extract actionable information and make data-informed decisions with ease.\n\n\ud83e\udde0 **Leverage Language Models**: Utilize state-of-the-art language models (LLMs) for text data. Querent empowers natural language processing, tackling complex text-based tasks.\n\n\ud83d\udcc8 **Efficient Memory Usage**: Querent is mindful of memory constraints. Our framework uses memory-efficient techniques, ensuring you can handle large datasets economically.\n\n## Table of Contents\n\n- [Querent](#querent)\n  - [Unlock Insights, Asynchronous Scaling, and Forge a Knowledge-Driven Future](#unlock-insights-asynchronous-scaling-and-forge-a-knowledge-driven-future)\n  - [Table of Contents](#table-of-contents)\n  - [Introduction](#introduction)\n  - [Features](#features)\n  - [Getting Started](#getting-started)\n    - [Prerequisites](#prerequisites)\n    - [Installation](#installation)\n  - [Usage](#usage)\n  - [Configuration](#configuration)\n  - [Querent: an asynchronous engine for LLMs](#querent-an-asynchronous-engine-for-llms)\n  - [Ease of Use](#ease-of-use)\n  - [Contributing](#contributing)\n  - [License](#license)\n\n## Introduction\n\nQuerent is designed to simplify and optimize data collection and processing workflows. Whether you need to scrape web data, ingest files, preprocess text, or create complex knowledge graphs, Querent offers a flexible framework for building and scaling these processes.\n\n## Features\n\n- **Collectors:** Gather data from various sources asynchronously, including web scraping and file collection.\n\n- **Ingestors:** Process collected data efficiently with custom transformations and filtering.\n\n- **Processors:** Apply asynchronous data processing, including text preprocessing, cleaning, and feature extraction.\n\n- **Engines:** Execute a suite of LLM engines to extract insights from data, leveraging parallel processing for enhanced efficiency.\n\n- **Storage:** Store processed data in various storage systems, such as databases or cloud storage.\n\n- **Workflow Management:** Efficiently manage and scale data workflows with task orchestration.\n\n- **Scalability:** Querent is designed to scale horizontally, handling large volumes of data with ease.\n\n## Getting Started\n\nLet's get Querent up and running on your local machine.\n\n### Prerequisites\n\n- Python 3.9+\n- Virtual environment (optional but recommended)\n\n### Installation\n\n1. Create a virtual environment (recommended):\n\n   ```bash\n   python -m venv venv\n   source venv/bin/activate  # On Windows, use `venv\\Scripts\\activate`\n   ```\n2. Install latest Querent Workflow Orchestrator package:\n\n   ```bash\n   pip install querent\n   ```\n  \n3. Install the project dependencies:\n\n   ```bash\n     python3 -m spacy download en_core_web_lg\n   ```\n\n4. Apt install the project dependencies:\n   ```bash\n        sudo apt install tesseract-ocr\n        sudo apt install libtesseract-dev\n        sudo apt-get install ffmpeg\n        sudo apt install antiword\n    ```\n\n## Usage\n\nQuerent provides a flexible framework that adapts to your specific data collection and processing needs. Here's how to get started:\n\n1. **Configuration:** Set up collector, ingestor, and processor configurations as needed.\n\n2. **Collecting Data:** Implement collector classes to gather data from chosen sources. Handle errors and edge cases gracefully.\n\n3. **Processing Data:** Create ingestors and processors to clean, transform, and filter collected data. Apply custom logic to meet your requirements.\n\n4. **Storage:** Choose your storage system (e.g., databases) and configure connections. Store processed data efficiently.\n\n5. **Task Orchestration:** For large tasks, implement a task orchestrator to manage and distribute the workload.\n\n6. **Scaling:** To handle scalability, consider running multiple instances of collectors and ingestors in parallel.\n\n7. **Monitoring:** Implement monitoring and logging to track task progress, detect errors, and ensure smooth operation.\n\n8. **Documentation:** Maintain thorough project documentation to make it easy for others (and yourself) to understand and contribute.\n\n## Configuration\n\nQuerent relies on configuration files to define how collectors, ingestors, and processors operate. These files are typically located in the `config` directory. Ensure that you configure the components according to your project's requirements.\n\n## Querent: an asynchronous engine for LLMs\n\n**Sequence Diagram:** *Asynchronous Data Processing in Querent*\n\n```mermaid\nsequenceDiagram\n    participant User\n    participant Collector\n    participant Ingestor\n    participant Processor\n    participant LLM\n    participant Querent\n    participant Storage\n    participant Callback\n\n    User->>Collector: Initiate Data Collection\n    Collector->>Ingestor: Collect Data\n    Ingestor->>Processor: Ingest Data\n    Processor->>LLM: Process Data (IngestedTokens)\n    LLM->>Processor: Processed Data (EventState)\n    Processor->>Storage: Store Processed Data (CollectedBytes)\n    Ingestor->>Querent: Send Ingested Data (IngestedTokens)\n    Querent->>Processor: Process Ingested Data (IngestedTokens)\n    Processor->>LLM: Process Data (IngestedTokens)\n    LLM->>Processor: Processed Data (EventState)\n    Callback->>Storage: Store Processed Data (EventState)\n    Querent->>Processor: Processed Data Available (EventState)\n    Processor->>Callback: Return Processed Data (EventState)\n    Callback->>User: Deliver Processed Data (CollectedBytes)\n\n    Note right of User: Asynchronous Flow\n    Note right of Collector: Data Collection\n    Note right of Ingestor: Data Ingestion\n    Note right of Processor: Data Processing\n    Note right of LLM: Language Model Processing\n    Note right of Querent: Query Execution\n    Note right of Storage: Data Storage\n    Note right of Callback: Callback Invocation\n\n```\n\n## Ease of Use\n\nWith Querent, creating scalable workflows with any LLM is just a few lines of code.\n\n```python\nimport pytest\nimport uuid\nfrom pathlib import Path\nimport asyncio\n\nfrom querent.callback.event_callback_interface import EventCallbackInterface\nfrom querent.common.types.ingested_tokens import IngestedTokens\nfrom querent.common.types.ingested_code import IngestedCode\nfrom querent.common.types.ingested_images import IngestedImages\nfrom querent.common.types.ingested_messages import IngestedMessages\nfrom querent.common.types.querent_event import EventState, EventType\nfrom querent.common.types.querent_queue import QuerentQueue\nfrom querent.core.base_engine import BaseEngine\nfrom querent.querent.querent import Querent\nfrom querent.querent.resource_manager import ResourceManager\nfrom querent.collectors.collector_resolver import CollectorResolver\nfrom querent.common.uri import Uri\nfrom querent.config.collector.collector_config import FSCollectorConfig\nfrom querent.ingestors.ingestor_manager import IngestorFactoryManager\n\n# Create input and output queues\ninput_queue = QuerentQueue()\nresource_manager = ResourceManager()\n\n\n# Define a simple mock LLM engine for testing\nclass MockLLMEngine(BaseEngine):\n    def __init__(self, input_queue: QuerentQueue):\n        super().__init__(input_queue)\n\n    async def process_tokens(self, data: IngestedTokens):\n        if data is None or data.is_error():\n            # the LLM developer can raise an error here or do something else\n            # the developers of Querent can customize the behavior of Querent\n            # to handle the error in a way that is appropriate for the use case\n            self.set_termination_event()\n            return\n        # Set the state of the LLM\n        # At any given point during the execution of the LLM, the LLM developer\n        # can set the state of the LLM using the set_state method\n        # The state of the LLM is stored in the state attribute of the LLM\n        # The state of the LLM is published to subscribers of the LLM\n        current_state = EventState(EventType.Graph, 1.0, \"anything\", \"dummy.txt\")\n        await self.set_state(new_state=current_state)\n\n    async def process_code(self, data: IngestedCode):\n        pass\n\n    async def process_messages(self, data: IngestedMessages):\n        return super().process_messages(data)\n\n    async def process_images(self, data: IngestedImages):\n        return super().process_images(data)\n\n    def validate(self):\n        return True\n\n\n@pytest.mark.asyncio\nasync def test_example_workflow_with_querent():\n    # Initialize some collectors to collect the data\n    directory_path = \"path/to/your/data/directory\"\n    collectors = [\n        CollectorResolver().resolve(\n            Uri(\"file://\" + str(Path(directory_path).resolve())),\n            FSCollectorConfig(root_path=directory_path, id=str(uuid.uuid4())),\n        )\n    ]\n\n    # Connect to the collector\n    for collector in collectors:\n        await collector.connect()\n\n    # Set up the result queue\n    result_queue = asyncio.Queue()\n\n    # Create the IngestorFactoryManager\n    ingestor_factory_manager = IngestorFactoryManager(\n        collectors=collectors, result_queue=result_queue\n    )\n\n    # Start the ingest_all_async in a separate task\n    ingest_task = asyncio.create_task(ingestor_factory_manager.ingest_all_async())\n\n    ### A Typical Use Case ###\n    # Create an engine to harness the LLM\n    llm_mocker = MockLLMEngine(input_queue)\n\n    # Define a callback function to subscribe to state changes\n    class StateChangeCallback(EventCallbackInterface):\n        async def handle_event(self, event_type: EventType, event_state: EventState):\n            print(f\"New state: {event_state}\")\n            print(f\"New state type: {event_type}\")\n            assert event_state.event_type == EventType.Graph\n\n    # Subscribe to state change events\n    # This pattern is ideal as we can expose multiple events for each use case of the LLM\n    llm_mocker.subscribe(EventType.Graph, StateChangeCallback())\n\n    ## one can also subscribe to other events, e.g. EventType.CHAT_COMPLETION ...\n\n    # Create a Querent instance with a single MockLLM\n    # here we see the simplicity of the Querent\n    # massive complexity is hidden in the Querent,\n    # while being highly configurable, extensible, and scalable\n    # async architecture helps to scale to multiple querenters\n    # How async architecture works:\n    #   1. Querent starts a worker task for each querenter\n    #   2. Querenter starts a worker task for each worker\n    #   3. Each worker task runs in a loop, waiting for input data\n    #   4. When input data is received, the worker task processes the data\n    #   5. The worker task notifies subscribers of state changes\n    #   6. The worker task repeats steps 3-5 until termination\n    querent = Querent(\n        [llm_mocker],\n        resource_manager=resource_manager,\n    )\n    # Start the querent\n    querent_task = asyncio.create_task(querent.start())\n    await asyncio.gather(ingest_task, querent_task)\n\n\nif __name__ == \"__main__\":\n    asyncio.run(test_example_workflow_with_querent())\n\n\n```\n\n## Contributing\n\nContributions to Querent are welcome! Please follow our [contribution guidelines](CONTRIBUTING.md) to get started.\n\n## License\n\nThis project is licensed under the BSL-1.1 License - see the [LICENSE](LICENCE) file for details.\n",
    "bugtrack_url": null,
    "license": "Business Source License 1.1",
    "summary": "The Asynchronous Data Dynamo and Graph Neural Network Catalyst",
    "version": "3.1.2",
    "project_urls": {
        "Documentation": "https://github.com/Querent-ai/querent-ai/docs",
        "Homepage": "https://github.com/Querent-ai/querent-ai",
        "Issue Tracker": "https://github.com/Querent-ai/querent-ai/issues"
    },
    "split_keywords": [
        "graph neural network",
        " scalability",
        " data-driven insights",
        " gnn",
        " async",
        " knowledge graphs",
        " kg",
        " large language models",
        " asyncio",
        " insights",
        " aysnchronous",
        " llm",
        " transformers",
        " pytorch",
        " llama-index",
        " ai",
        " artificial intelligence",
        " neo4j",
        " queues",
        " quiassisstant",
        " collectors",
        " data",
        " data science",
        " data engineering",
        " data analysis",
        " data analytics",
        " news",
        " nlp",
        " natural language processing",
        " text",
        " text analysis",
        " deep learning",
        " graphs",
        " graph theory",
        " graph algorithms",
        " graph analytics",
        " graph databases",
        " graph processing",
        " graph mining",
        " graph neural networks",
        " gnn",
        " gnns",
        " graph neural network"
    ],
    "urls": [
        {
            "comment_text": "",
            "digests": {
                "blake2b_256": "d1ac1f2c1db7f0a03961f930dc4577739b93b20626d651a674f6eaf3716c2d52",
                "md5": "90aaec55a95ba1b08dff332cafc67198",
                "sha256": "735bedc019da661fc8ef0375fdf6c3de151ba0a7600f450676ec231bcea96456"
            },
            "downloads": -1,
            "filename": "querent-3.1.2-py3-none-any.whl",
            "has_sig": false,
            "md5_digest": "90aaec55a95ba1b08dff332cafc67198",
            "packagetype": "bdist_wheel",
            "python_version": "py3",
            "requires_python": "<3.11,>=3.10",
            "size": 171228,
            "upload_time": "2024-06-10T11:13:53",
            "upload_time_iso_8601": "2024-06-10T11:13:53.002493Z",
            "url": "https://files.pythonhosted.org/packages/d1/ac/1f2c1db7f0a03961f930dc4577739b93b20626d651a674f6eaf3716c2d52/querent-3.1.2-py3-none-any.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": "",
            "digests": {
                "blake2b_256": "cc1ddbc54045c170f9383ee186e8de7c4a291a1d105201df84cbee44d4630b5d",
                "md5": "dfb34d619ac5ac8401b341ef8e762f89",
                "sha256": "baf903e598a2decb623a552d9455b1448d6083541b796aece67f9aaa7631f103"
            },
            "downloads": -1,
            "filename": "querent-3.1.2.tar.gz",
            "has_sig": false,
            "md5_digest": "dfb34d619ac5ac8401b341ef8e762f89",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": "<3.11,>=3.10",
            "size": 115117,
            "upload_time": "2024-06-10T11:13:54",
            "upload_time_iso_8601": "2024-06-10T11:13:54.865961Z",
            "url": "https://files.pythonhosted.org/packages/cc/1d/dbc54045c170f9383ee186e8de7c4a291a1d105201df84cbee44d4630b5d/querent-3.1.2.tar.gz",
            "yanked": false,
            "yanked_reason": null
        }
    ],
    "upload_time": "2024-06-10 11:13:54",
    "github": true,
    "gitlab": false,
    "bitbucket": false,
    "codeberg": false,
    "github_user": "Querent-ai",
    "github_project": "querent-ai",
    "github_not_found": true,
    "lcname": "querent"
}
        
Elapsed time: 0.27664s