From 0f97f8f71be8d44088a630e4bbe90b25dac700c6 Mon Sep 17 00:00:00 2001 From: Boris Date: Mon, 13 Jan 2025 22:36:42 +0100 Subject: [PATCH] Version 0.1.22 (#438) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Revert "fix: Add metadata reflection fix to sqlite as well" This reverts commit 394a0b2dfb9645e58ed31835e8eaec7c90970358. * COG-810 Implement a top-down dependency graph builder tool (#268) * feat: parse repo to call graph * Update/repo_processor/top_down_repo_parse.py task * fix: minor improvements * feat: file parsing jedi script optimisation --------- * Add type to DataPoint metadata (#364) * Add missing index_fields * Use DataPoint UUID type in pgvector create_data_points * Make _metadata mandatory everywhere * feat: Add search by dataset for cognee Added ability to search by datasets for cognee users Feature COG-912 * feat: outsources chunking parameters to extract chunk from documents … (#289) * feat: outsources chunking parameters to extract chunk from documents task * fix: Remove backend lock from UI Removed lock that prevented using multiple datasets in cognify Fix COG-912 * COG 870 Remove duplicate edges from the code graph (#293) * feat: turn summarize_code into generator * feat: extract run_code_graph_pipeline, update the pipeline * feat: minimal code graph example * refactor: update argument * refactor: move run_code_graph_pipeline to cognify/code_graph_pipeline * refactor: indentation and whitespace nits * refactor: add deprecated use comments and warnings --------- Co-authored-by: Vasilije <8619304+Vasilije1990@users.noreply.github.com> Co-authored-by: Igor Ilic <30923996+dexters1@users.noreply.github.com> Co-authored-by: Boris * test: Added test for getting of documents for search Added test to verify getting documents related to datasets intended for search Test COG-912 * Structured code summarization (#375) * feat: turn summarize_code into generator * feat: extract run_code_graph_pipeline, update the pipeline * feat: minimal code graph example * refactor: update argument * refactor: move run_code_graph_pipeline to cognify/code_graph_pipeline * refactor: indentation and whitespace nits * refactor: add deprecated use comments and warnings * Structured code summarization * add missing prompt file * Remove summarization_model argument from summarize_code and fix typehinting * minor refactors --------- Co-authored-by: lxobr <122801072+lxobr@users.noreply.github.com> Co-authored-by: Vasilije <8619304+Vasilije1990@users.noreply.github.com> Co-authored-by: Igor Ilic <30923996+dexters1@users.noreply.github.com> Co-authored-by: Boris * fix: Resolve issue with cognify router graph model default value Resolve issue with default value for graph model in cognify endpoint Fix * chore: Resolve typo in getting documents code Resolve typo in code chore COG-912 * Update .github/workflows/dockerhub.yml Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> * Update .github/workflows/dockerhub.yml * Update .github/workflows/dockerhub.yml * Update .github/workflows/dockerhub.yml * Update get_cognify_router.py * fix: Resolve syntax issue with cognify router Resolve syntax issue with cognify router Fix * feat: Add ruff pre-commit hook for linting and formatting Added formatting and linting on pre-commit hook Feature COG-650 * chore: Update ruff lint options in pyproject file Update ruff lint options in pyproject file Chore * test: Add ruff linter github action Added linting check with ruff in github actions Test COG-650 * feat: deletes executor limit from get_repo_file_dependencies * feat: implements mock feature in LiteLLM engine * refactor: Remove changes to cognify router Remove changes to cognify router Refactor COG-650 * fix: fixing boolean env for github actions * test: Add test for ruff format for cognee code Test if code is formatted for cognee Test COG-650 * refactor: Rename ruff gh actions Rename ruff gh actions to be more understandable Refactor COG-650 * chore: Remove checking of ruff lint and format on push Remove checking of ruff lint and format on push Chore COG-650 * feat: Add deletion of local files when deleting data Delete local files when deleting data from cognee Feature COG-475 * fix: changes back the max workers to 12 * feat: Adds mock summary for codegraph pipeline * refacotr: Add current development status Save current development status Refactor * Fix langfuse * Fix langfuse * Fix langfuse * Add evaluation notebook * Rename eval notebook * chore: Add temporary state of development Add temp development state to branch Chore * fix: Add poetry.lock file, make langfuse mandatory Added langfuse as mandatory dependency, added poetry.lock file Fix * Fix: fixes langfuse config settings * feat: Add deletion of local files made by cognee through data endpoint Delete local files made by cognee when deleting data from database through endpoint Feature COG-475 * test: Revert changes on test_pgvector Revert changes on test_pgvector which were made to test deletion of local files Test COG-475 * chore: deletes the old test for the codegraph pipeline * test: Add test to verify deletion of local files Added test that checks local files created by cognee will be deleted and those not created by cognee won't Test COG-475 * chore: deletes unused old version of the codegraph * chore: deletes unused imports from code_graph_pipeline * Ingest non-code files * Fixing review findings * Ingest non-code files (#395) * Ingest non-code files * Fixing review findings * test: Update test regarding message Update assertion message, add veryfing of file existence * Handle retryerrors in code summary (#396) * Handle retryerrors in code summary * Log instead of print * fix: updates the acreate_structured_output * chore: Add logging to sentry when file which should exist can't be found Log to sentry that a file which should exist can't be found Chore COG-475 * Fix diagram * fix: refactor mcp * Add Smithery CLI installation instructions and badge * Move readme * Update README.md * Update README.md * Cog 813 source code chunks (#383) * fix: pass the list of all CodeFiles to enrichment task * feat: introduce SourceCodeChunk, update metadata * feat: get_source_code_chunks code graph pipeline task * feat: integrate get_source_code_chunks task, comment out summarize_code * Fix code summarization (#387) * feat: update data models * feat: naive parse long strings in source code * fix: get_non_py_files instead of get_non_code_files * fix: limit recursion, add comment * handle embedding empty input error (#398) * feat: robustly handle CodeFile source code * refactor: sort imports * todo: add support for other embedding models * feat: add custom logger * feat: add robustness to get_source_code_chunks Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> * feat: improve embedding exceptions * refactor: format indents, rename module --------- Co-authored-by: alekszievr <44192193+alekszievr@users.noreply.github.com> Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> * Fix diagram * Fix diagram * Fix instructions * Fix instructions * adding and fixing files * Update README.md * ruff format * Fix linter issues * Fix linter issues * Fix linter issues * Fix linter issues * Fix linter issues * Fix linter issues * Fix linter issues * Fix linter issues * Fix linter issues * Fix linter issues * Implement PR review * Comment out profiling * Comment out profiling * Comment out profiling * fix: add allowed extensions * fix: adhere UnstructuredDocument.read() to Document * feat: time code graph run and add mock support * Fix ollama, work on visualization * fix: Fixes faulty logging format and sets up error logging in dynamic steps example * Overcome ContextWindowExceededError by checking token count while chunking (#413) * fix: Fixes duplicated edges in cognify by limiting the recursion depth in add datapoints * Adjust AudioDocument and handle None token limit * Handle azure models as well * Fix visualization * Fix visualization * Fix visualization * Add clean logging to code graph example * Remove setting envvars from arg * fix: fixes create_cognee_style_network_with_logo unit test * fix: removes accidental remained print * Fix visualization * Fix visualization * Fix visualization * Get embedding engine instead of passing it. Get it from vector engine instead of direct getter. * Fix visualization * Fix visualization * Fix poetry issues * Get embedding engine instead of passing it in code chunking. * Fix poetry issues * Fix poetry issues * Fix poetry issues * Fix poetry issues * Fix poetry issues * Fix poetry issues * Fix poetry issues * Fix poetry issues * chore: Update version of poetry install action * chore: Update action to trigger on pull request for any branch * chore: Remove if in github action to allow triggering on push * chore: Remove if condition to allow gh actions to trigger on push to PR * chore: Update poetry version in github actions * chore: Set fixed ubuntu version to 22.04 * chore: Update py lint to use ubuntu 22.04 * chore: update ubuntu version to 22.04 * feat: implements the first version of graph based completion in search * chore: Update python 3.9 gh action to use 3.12 instead * chore: Update formatting of utils.py * Fix poetry issues * Fix poetry issues * Fix poetry issues * Fix poetry issues * Fix poetry issues * Fix poetry issues * Fix poetry issues * Adjust integration tests * fix: Fixes ruff formatting * Handle circular import * fix: Resolve profiler issue with partial and recursive logger imports Resolve issue for profiler with partial and recursive logger imports * fix: Remove logger from __init__.py file * test: Test profiling on HEAD branch * test: Return profiler to base branch * Set max_tokens in config * Adjust SWE-bench script to code graph pipeline call * Adjust SWE-bench script to code graph pipeline call * fix: Add fix for accessing dictionary elements that don't exits Using get for the text key instead of direct access to handle situation if the text key doesn't exist * feat: Add ability to change graph database configuration through cognee * feat: adds pydantic types to graph layer models * test: Test ubuntu 24.04 * test: change all actions to ubuntu-latest * feat: adds basic retriever for swe bench * Match Ruff version in config to the one in github actions * feat: implements code retreiver * Fix: fixes unit test for codepart search * Format with Ruff 0.9.0 * Fix: deleting incorrect repo path * docs: Add LlamaIndex Cognee integration notebook Added LlamaIndex Cognee integration notebook * test: Add github action for testing llama index cognee integration notebook * fix: resolve issue with langfuse dependency installation when integrating cognee in different packages * version: Increase version to 0.1.21 * fix: update dependencies of the mcp server * Update README.md * Fix: Fixes logging setup * feat: deletes on the fly embeddings as uses edge collections * fix: Change nbformat on llama index integration notebook * fix: Resolve api key issue with llama index integration notebook * fix: Attempt to resolve issue with Ubuntu 24.04 segmentation fault * version: Increase version to 0.1.22 --------- Co-authored-by: vasilije Co-authored-by: Igor Ilic Co-authored-by: Igor Ilic <30923996+dexters1@users.noreply.github.com> Co-authored-by: lxobr <122801072+lxobr@users.noreply.github.com> Co-authored-by: alekszievr <44192193+alekszievr@users.noreply.github.com> Co-authored-by: hajdul88 <52442977+hajdul88@users.noreply.github.com> Co-authored-by: Vasilije <8619304+Vasilije1990@users.noreply.github.com> Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> Co-authored-by: Rita Aleksziev Co-authored-by: Henry Mao <1828968+calclavia@users.noreply.github.com> --- .github/workflows/dockerhub.yml | 2 +- .github/workflows/py_lint.yml | 2 +- .github/workflows/reusable_notebook.yml | 1 + .github/workflows/ruff_format.yaml | 2 +- .github/workflows/ruff_lint.yaml | 2 +- .github/workflows/test_deduplication.yml | 2 +- ...lama_index_cognee_integration_notebook.yml | 20 ++ .github/workflows/test_qdrant.yml | 2 +- .github/workflows/test_weaviate.yml | 2 +- README.md | 12 +- .../modules/graph/cognee_graph/CogneeGraph.py | 38 +-- .../retrieval/brute_force_triplet_search.py | 25 +- .../modules/users/methods/get_default_user.py | 4 +- cognee/shared/utils.py | 14 +- examples/python/dynamic_steps_example.py | 2 +- .../llama_index_cognee_integration.ipynb | 285 ++++++++++++++++++ pyproject.toml | 2 +- 17 files changed, 336 insertions(+), 81 deletions(-) create mode 100644 .github/workflows/test_llama_index_cognee_integration_notebook.yml create mode 100644 notebooks/llama_index_cognee_integration.ipynb diff --git a/.github/workflows/dockerhub.yml b/.github/workflows/dockerhub.yml index 20f0bde96..b48dde2cc 100644 --- a/.github/workflows/dockerhub.yml +++ b/.github/workflows/dockerhub.yml @@ -7,7 +7,7 @@ on: jobs: docker-build-and-push: - runs-on: ubuntu-22.04 + runs-on: ubuntu-latest steps: - name: Checkout repository diff --git a/.github/workflows/py_lint.yml b/.github/workflows/py_lint.yml index 543a0d221..11d0a8b7d 100644 --- a/.github/workflows/py_lint.yml +++ b/.github/workflows/py_lint.yml @@ -16,7 +16,7 @@ jobs: fail-fast: true matrix: os: - - ubuntu-22.04 + - ubuntu-latest python-version: ["3.10.x", "3.11.x"] defaults: diff --git a/.github/workflows/reusable_notebook.yml b/.github/workflows/reusable_notebook.yml index 8034aca97..9bc09c3a6 100644 --- a/.github/workflows/reusable_notebook.yml +++ b/.github/workflows/reusable_notebook.yml @@ -51,6 +51,7 @@ jobs: env: ENV: 'dev' LLM_API_KEY: ${{ secrets.OPENAI_API_KEY }} + OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }} GRAPHISTRY_USERNAME: ${{ secrets.GRAPHISTRY_USERNAME }} GRAPHISTRY_PASSWORD: ${{ secrets.GRAPHISTRY_PASSWORD }} run: | diff --git a/.github/workflows/ruff_format.yaml b/.github/workflows/ruff_format.yaml index a75a795e7..959b7fc4b 100644 --- a/.github/workflows/ruff_format.yaml +++ b/.github/workflows/ruff_format.yaml @@ -3,7 +3,7 @@ on: [ pull_request ] jobs: ruff: - runs-on: ubuntu-22.04 + runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: astral-sh/ruff-action@v2 diff --git a/.github/workflows/ruff_lint.yaml b/.github/workflows/ruff_lint.yaml index 4c4fb81e3..214e8ec6d 100644 --- a/.github/workflows/ruff_lint.yaml +++ b/.github/workflows/ruff_lint.yaml @@ -3,7 +3,7 @@ on: [ pull_request ] jobs: ruff: - runs-on: ubuntu-22.04 + runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: astral-sh/ruff-action@v2 diff --git a/.github/workflows/test_deduplication.yml b/.github/workflows/test_deduplication.yml index 923bbb68c..2f97e4ea6 100644 --- a/.github/workflows/test_deduplication.yml +++ b/.github/workflows/test_deduplication.yml @@ -16,7 +16,7 @@ env: jobs: run_deduplication_test: name: test - runs-on: ubuntu-22.04 + runs-on: ubuntu-latest defaults: run: shell: bash diff --git a/.github/workflows/test_llama_index_cognee_integration_notebook.yml b/.github/workflows/test_llama_index_cognee_integration_notebook.yml new file mode 100644 index 000000000..aacc31eb5 --- /dev/null +++ b/.github/workflows/test_llama_index_cognee_integration_notebook.yml @@ -0,0 +1,20 @@ +name: test | llama index cognee integration notebook + +on: + workflow_dispatch: + pull_request: + types: [labeled, synchronize] + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +jobs: + run_notebook_test: + uses: ./.github/workflows/reusable_notebook.yml + with: + notebook-location: notebooks/llama_index_cognee_integration.ipynb + secrets: + OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }} + GRAPHISTRY_USERNAME: ${{ secrets.GRAPHISTRY_USERNAME }} + GRAPHISTRY_PASSWORD: ${{ secrets.GRAPHISTRY_PASSWORD }} diff --git a/.github/workflows/test_qdrant.yml b/.github/workflows/test_qdrant.yml index d1447c65c..e2cf9abe8 100644 --- a/.github/workflows/test_qdrant.yml +++ b/.github/workflows/test_qdrant.yml @@ -17,7 +17,7 @@ jobs: run_qdrant_integration_test: name: test - runs-on: ubuntu-22.04 + runs-on: ubuntu-latest defaults: run: shell: bash diff --git a/.github/workflows/test_weaviate.yml b/.github/workflows/test_weaviate.yml index 159fce194..81cc2603f 100644 --- a/.github/workflows/test_weaviate.yml +++ b/.github/workflows/test_weaviate.yml @@ -17,7 +17,7 @@ jobs: run_weaviate_integration_test: name: test - runs-on: ubuntu-22.04 + runs-on: ubuntu-latest defaults: run: shell: bash diff --git a/README.md b/README.md index f35829783..8ff2d71d5 100644 --- a/README.md +++ b/README.md @@ -101,15 +101,9 @@ cognee.config.set_graphistry_config({ }) ``` -(Optional) To run the UI, go to cognee-frontend directory and run: -``` -npm run dev -``` -or run everything in a docker container: -``` -docker-compose up -``` -Then navigate to localhost:3000 +(Optional) To run the with an UI, go to cognee-mcp directory and follow the instructions. +You will be able to use cognee as mcp tool and create graphs and query them. + If you want to use Cognee with PostgreSQL, make sure to set the following values in the .env file: ``` diff --git a/cognee/modules/graph/cognee_graph/CogneeGraph.py b/cognee/modules/graph/cognee_graph/CogneeGraph.py index 279a73b19..491f83b5a 100644 --- a/cognee/modules/graph/cognee_graph/CogneeGraph.py +++ b/cognee/modules/graph/cognee_graph/CogneeGraph.py @@ -8,7 +8,7 @@ from cognee.infrastructure.databases.graph.graph_db_interface import GraphDBInte from cognee.modules.graph.cognee_graph.CogneeGraphElements import Node, Edge from cognee.modules.graph.cognee_graph.CogneeAbstractGraph import CogneeAbstractGraph import heapq -from graphistry import edges +import asyncio class CogneeGraph(CogneeAbstractGraph): @@ -127,51 +127,25 @@ class CogneeGraph(CogneeAbstractGraph): else: print(f"Node with id {node_id} not found in the graph.") - async def map_vector_distances_to_graph_edges( - self, vector_engine, query - ) -> None: # :TODO: When we calculate edge embeddings in vector db change this similarly to node mapping + async def map_vector_distances_to_graph_edges(self, vector_engine, query) -> None: try: - # Step 1: Generate the query embedding query_vector = await vector_engine.embed_data([query]) query_vector = query_vector[0] if query_vector is None or len(query_vector) == 0: raise ValueError("Failed to generate query embedding.") - # Step 2: Collect all unique relationship types - unique_relationship_types = set() - for edge in self.edges: - relationship_type = edge.attributes.get("relationship_type") - if relationship_type: - unique_relationship_types.add(relationship_type) + edge_distances = await vector_engine.get_distance_from_collection_elements( + "edge_type_relationship_name", query_text=query + ) - # Step 3: Embed all unique relationship types - unique_relationship_types = list(unique_relationship_types) - relationship_type_embeddings = await vector_engine.embed_data(unique_relationship_types) + embedding_map = {result.payload["text"]: result.score for result in edge_distances} - # Step 4: Map relationship types to their embeddings and calculate distances - embedding_map = {} - for relationship_type, embedding in zip( - unique_relationship_types, relationship_type_embeddings - ): - edge_vector = np.array(embedding) - - # Calculate cosine similarity - similarity = np.dot(query_vector, edge_vector) / ( - np.linalg.norm(query_vector) * np.linalg.norm(edge_vector) - ) - distance = 1 - similarity - - # Round the distance to 4 decimal places and store it - embedding_map[relationship_type] = round(distance, 4) - - # Step 4: Assign precomputed distances to edges for edge in self.edges: relationship_type = edge.attributes.get("relationship_type") if not relationship_type or relationship_type not in embedding_map: print(f"Edge {edge} has an unknown or missing relationship type.") continue - # Assign the precomputed distance edge.attributes["vector_distance"] = embedding_map[relationship_type] except Exception as ex: diff --git a/cognee/modules/retrieval/brute_force_triplet_search.py b/cognee/modules/retrieval/brute_force_triplet_search.py index 9c778505d..c27e90766 100644 --- a/cognee/modules/retrieval/brute_force_triplet_search.py +++ b/cognee/modules/retrieval/brute_force_triplet_search.py @@ -62,24 +62,6 @@ async def brute_force_triplet_search( return retrieved_results -def delete_duplicated_vector_db_elements( - collections, results -): #:TODO: This is just for now to fix vector db duplicates - results_dict = {} - for collection, results in zip(collections, results): - seen_ids = set() - unique_results = [] - for result in results: - if result.id not in seen_ids: - unique_results.append(result) - seen_ids.add(result.id) - else: - print(f"Duplicate found in collection '{collection}': {result.id}") - results_dict[collection] = unique_results - - return results_dict - - async def brute_force_search( query: str, user: User, top_k: int, collections: List[str] = None ) -> list: @@ -125,10 +107,7 @@ async def brute_force_search( ] ) - ############################################# :TODO: Change when vector db does not contain duplicates - node_distances = delete_duplicated_vector_db_elements(collections, results) - # node_distances = {collection: result for collection, result in zip(collections, results)} - ############################################## + node_distances = {collection: result for collection, result in zip(collections, results)} memory_fragment = CogneeGraph() @@ -140,14 +119,12 @@ async def brute_force_search( await memory_fragment.map_vector_distances_to_graph_nodes(node_distances=node_distances) - #:TODO: Change when vectordb contains edge embeddings await memory_fragment.map_vector_distances_to_graph_edges(vector_engine, query) results = await memory_fragment.calculate_top_triplet_importances(k=top_k) send_telemetry("cognee.brute_force_triplet_search EXECUTION STARTED", user.id) - #:TODO: Once we have Edge pydantic models we should retrieve the exact edge and node objects from graph db return results except Exception as e: diff --git a/cognee/modules/users/methods/get_default_user.py b/cognee/modules/users/methods/get_default_user.py index c67d9d71f..2bb15ea95 100644 --- a/cognee/modules/users/methods/get_default_user.py +++ b/cognee/modules/users/methods/get_default_user.py @@ -1,4 +1,4 @@ -from sqlalchemy.orm import joinedload +from sqlalchemy.orm import selectinload from sqlalchemy.future import select from cognee.modules.users.models import User from cognee.infrastructure.databases.relational import get_relational_engine @@ -11,7 +11,7 @@ async def get_default_user(): async with db_engine.get_async_session() as session: query = ( select(User) - .options(joinedload(User.groups)) + .options(selectinload(User.groups)) .where(User.email == "default_user@example.com") ) diff --git a/cognee/shared/utils.py b/cognee/shared/utils.py index e57decde1..affd92c87 100644 --- a/cognee/shared/utils.py +++ b/cognee/shared/utils.py @@ -468,16 +468,20 @@ def graph_to_tuple(graph): def setup_logging(log_level=logging.INFO): - """This method sets up the logging configuration.""" + """Sets up the logging configuration.""" formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s\n") + stream_handler = logging.StreamHandler(sys.stdout) stream_handler.setFormatter(formatter) stream_handler.setLevel(log_level) - logging.basicConfig( - level=log_level, - handlers=[stream_handler], - ) + root_logger = logging.getLogger() + + if root_logger.hasHandlers(): + root_logger.handlers.clear() + + root_logger.addHandler(stream_handler) + root_logger.setLevel(log_level) # ---------------- Example Usage ---------------- diff --git a/examples/python/dynamic_steps_example.py b/examples/python/dynamic_steps_example.py index 11596a5e2..4422dd39d 100644 --- a/examples/python/dynamic_steps_example.py +++ b/examples/python/dynamic_steps_example.py @@ -192,7 +192,7 @@ async def main(enable_steps): if __name__ == "__main__": - setup_logging(logging.INFO) + setup_logging(logging.ERROR) rebuild_kg = True retrieve = True diff --git a/notebooks/llama_index_cognee_integration.ipynb b/notebooks/llama_index_cognee_integration.ipynb new file mode 100644 index 000000000..772c0a8c7 --- /dev/null +++ b/notebooks/llama_index_cognee_integration.ipynb @@ -0,0 +1,285 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## LlamaIndex Cognee GraphRAG Integration\n", + "\n", + "Connecting external knowledge to the LLM efficiently and retrieving it is a key challenge faced by developers. For developers and data scientists, integrating structured and unstructured data into AI workflows often involves multiple tools, complex pipelines, and time-consuming processes.\n", + "\n", + "Enter **cognee,** a powerful framework for knowledge and memory management, and LlamaIndex, a versatile data integration library. Together, they enable us to transform retrieval-augmented generation (RAG) pipelines, into GraphRAG pipelines, streamlining the path from raw data to actionable insights.\n", + "\n", + "In this post, we’ll explore a demo that leverages cognee and LlamaIndex to create a knowledge graph from a LlamaIndex document, process it into a meaningful structure, and extract useful insights. By the end, you’ll see how these tools can give you new insights into your data by connecting various data sources in one big semantic layer you can analyze.\n", + "\n", + "## RAG - Recap\n", + "\n", + "RAG enhances LLMs by integrating external knowledge sources during inference. It does so by turning the data into a vector representation and storing it in a vector store.\n", + "\n", + "### Key Benefits of RAG:\n", + "\n", + "1. Connecting domain specific data to LLMs\n", + "2. Cost savings\n", + "3. Higher accuracy than base LLM\n", + "\n", + "However, building a RAG system presents challenges: handling diverse data formats, data updates, creating a robust metadata layer, and mediocre accuracy\n", + "\n", + "## Introducing cognee and LlamaIndex more\n", + "\n", + "cognee simplifies knowledge and memory management for LLMs, while LlamaIndex facilitates connecting LLMs to structured data sources and enabling agentic use-cases\n", + "\n", + "cognee is inspired by human mind and higer cognitive functions. It mimics ways we construct our mental map of the world and build a semantic understanding of various objects, terms and issues in our everyday lives.\n", + "\n", + "cognee brings this approach to code by allowing developers to create semantic layers that would allow users to store their ontologies which are **a formalised depiction of knowledge** in graphs.\n", + "\n", + "This lets you use the knowledge you have about a system connect it to LLMs in a modular way, with best data engineering practices, wide choice of vector and graph stores and various LLMs you can use.\n", + "\n", + "Together, they:\n", + "\n", + "- Turn unstructured and semi-structured data into a graph/vector representation.\n", + "- Enable ontology generation for particular domains, making unique graphs for every vertical\n", + "- Provide a deterministic layer for LLM outputs, ensuring consistency and reliability.\n", + "\n", + "## Step-by-Step Demo: Building a RAG System with Cognee and LlamaIndex\n", + "\n", + "### 1. Setting Up the Environment\n", + "\n", + "Start by importing the required libraries and defining the environment:" + ], + "id": "d0d7a82d729bbef6" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "!pip install llama-index-graph-rag-cognee==0.1.1", + "id": "598b52e384086512" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "import os\n", + "import asyncio\n", + "from llama_index.core import Document\n", + "from llama_index.graph_rag.cognee import CogneeGraphRAG\n", + "\n", + "if \"OPENAI_API_KEY\" not in os.environ:\n", + " os.environ[\"OPENAI_API_KEY\"] = \"\"" + ], + "id": "892a1b1198ec662f" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "Ensure you’ve set up your API keys and installed necessary dependencies.\n", + "\n", + "### 2. Preparing the Dataset\n", + "\n", + "We’ll use a brief profile of an individual as our sample dataset:" + ], + "id": "a1f16f5ca5249ebb" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "documents = [\n", + " Document(\n", + " text=\"Jessica Miller, Experienced Sales Manager with a strong track record in driving sales growth and building high-performing teams.\"\n", + " ),\n", + " Document(\n", + " text=\"David Thompson, Creative Graphic Designer with over 8 years of experience in visual design and branding.\"\n", + " ),\n", + " ]" + ], + "id": "198022c34636a3a0" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### 3. Initializing CogneeGraphRAG\n", + "\n", + "Instantiate the Cognee framework with configurations for LLM, graph, and database providers:" + ], + "id": "781ae78e52ff49a" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "cogneeRAG = CogneeGraphRAG(\n", + " llm_api_key=os.environ[\"OPENAI_API_KEY\"],\n", + " llm_provider=\"openai\",\n", + " llm_model=\"gpt-4o-mini\",\n", + " graph_db_provider=\"networkx\",\n", + " vector_db_provider=\"lancedb\",\n", + " relational_db_provider=\"sqlite\",\n", + " relational_db_name=\"cognee_db\",\n", + ")" + ], + "id": "17e466821ab88d50" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### 4. Adding Data to Cognee\n", + "\n", + "Load the dataset into the cognee framework:" + ], + "id": "2a55d5be9de0ce81" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "await cogneeRAG.add(documents, \"test\")", + "id": "238b716429aba541" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "This step prepares the data for graph-based processing.\n", + "\n", + "### 5. Processing Data into a Knowledge Graph\n", + "\n", + "Transform the data into a structured knowledge graph:" + ], + "id": "23e5316aa7e5dbc7" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "await cogneeRAG.process_data(\"test\")", + "id": "c3b3063d428b07a2" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "The graph now contains nodes and relationships derived from the dataset, creating a powerful structure for exploration.\n", + "\n", + "### 6. Performing Searches\n", + "\n", + "### Answer prompt based on knowledge graph approach:" + ], + "id": "e32327de54e98dc8" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "search_results = await cogneeRAG.search(\"Tell me who are the people mentioned?\")\n", + "\n", + "print(\"\\n\\nAnswer based on knowledge graph:\\n\")\n", + "for result in search_results:\n", + " print(f\"{result}\\n\")" + ], + "id": "fddbf5916d1e50e5" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Answer prompt based on RAG approach:", + "id": "9246aed7f69ceb7e" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "search_results = await cogneeRAG.rag_search(\"Tell me who are the people mentioned?\")\n", + "\n", + "print(\"\\n\\nAnswer based on RAG:\\n\")\n", + "for result in search_results:\n", + " print(f\"{result}\\n\")" + ], + "id": "fe77c7a7c57fe4e4" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "In conclusion, the results demonstrate a significant advantage of the knowledge graph-based approach (Graphrag) over the RAG approach. Graphrag successfully identified all the mentioned individuals across multiple documents, showcasing its ability to aggregate and infer information from a global context. In contrast, the RAG approach was limited to identifying individuals within a single document due to its chunking-based processing constraints. This highlights Graphrag's superior capability in comprehensively resolving queries that span across a broader corpus of interconnected data.", + "id": "89cc99628392eb99" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### 7. Finding Related Nodes\n", + "\n", + "Explore relationships in the knowledge graph:" + ], + "id": "44c9b67c09763610" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "related_nodes = await cogneeRAG.get_related_nodes(\"person\")\n", + "\n", + "print(\"\\n\\nRelated nodes are:\\n\")\n", + "for node in related_nodes:\n", + " print(f\"{node}\\n\")" + ], + "id": "efbc1511586f46fe" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Why Choose Cognee and LlamaIndex?\n", + "\n", + "### 1. Agentic Framework and Memory tied together\n", + "\n", + "Your agents can now get long-term, short-term memory and memory specific to their domains\n", + "\n", + "### 2. Enhanced Querying and Insights\n", + "\n", + "Your memory can now automatically optimize itself and allow to respond to questions better\n", + "\n", + "### 3. Simplified Deployment\n", + "\n", + "You can use the standard tools out of the box and get things done without much effort\n", + "\n", + "## Visualizing the Knowledge Graph\n", + "\n", + "Imagine a graph structure where each node represents a document or entity, and edges indicate relationships.\n", + "\n", + "Here’s the visualized knowledge graph from the simple example above:\n", + "\n", + "![example.png](data:image/jpeg;base64,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)\n", + "\n", + "\n", + "## Conclusion\n", + "\n", + "Try running it yourself\n", + "\n", + "Join cognee community" + ], + "id": "d0f82c2c6eb7793" + } + ], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pyproject.toml b/pyproject.toml index 5a0e83057..446e807de 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "cognee" -version = "0.1.21" +version = "0.1.22" description = "Cognee - is a library for enriching LLM context with a semantic layer for better understanding and reasoning." authors = ["Vasilije Markovic", "Boris Arzentar"] readme = "README.md"