cognee 0.5.1.dev0__py3-none-any.whl → 0.5.2__py3-none-any.whl

cognee/modules/notebooks/tutorials/cognee-basics/cell-5.py

@@ -0,0 +1,3 @@
+# Run cognify to process the data and create a knowledge graph
+
+await cognee.cognify(datasets=["cognee-basics"])

cognee/modules/notebooks/tutorials/cognee-basics/cell-6.py

@@ -0,0 +1,9 @@
+# And after the cognification, search the knowledge graph
+
+result = await cognee.search(
+    "Which characters belong to Gryffindor?",
+    datasets=["cognee-basics"],
+)
+
+# Print the result so you can see it in the notebook output
+print(result)

cognee/modules/notebooks/tutorials/cognee-basics/cell-7.py

@@ -0,0 +1,17 @@
+# Run multiple searches and print the results
+
+result_1 = await cognee.search(
+    "Who taught Potions at Hogwarts at time Albus Dumbledore was the headmaster?",
+    datasets=["cognee-basics"],
+)
+
+# Print the result so you can see it in the notebook output
+print(result_1)
+
+
+result_2 = await cognee.search(
+    "How to defeat Voldemort?",
+    datasets=["cognee-basics"],
+)
+
+print(result_2)

cognee/modules/notebooks/tutorials/cognee-basics/config.json

@@ -0,0 +1,4 @@
+{
+  "name": "Cognee Basics - tutorial 🧠",
+  "deletable": false
+}

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-1.md

@@ -0,0 +1,3 @@
+# Using Cognee with Python Development Data
+
+Unite authoritative Python practice (Guido van Rossum's own contributions!), normative guidance (Zen/PEP 8), and your lived context (rules + conversations) into one AI memory that produces answers that are relevant, explainable, and consistent.

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-10.md

@@ -0,0 +1,3 @@
+You'll see that cognee has connected your Python development challenges with Guido's approaches, revealing patterns like:
+- "Type hint implementation failed due to circular imports - similar to issue Guido solved in mypy PR #1234"
+- "Performance bottleneck in list comprehension matches pattern Guido optimized in CPython commit abc123"

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-11.md

@@ -0,0 +1,3 @@
+# Memify
+
+Let's now introduce the memory functions. These algorithms run on top of your semantic layer, connecting the dots and improving the reasoning in search.

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-12.py

@@ -0,0 +1,3 @@
+memify_result = await cognee.memify(dataset="python-development-with-cognee")
+
+print(memify_result)

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-13.md

@@ -0,0 +1,7 @@
+# What Memify Does in This Case
+
+This advanced function uses AI to:
+- Infer rule patterns from your code (e.g., "When implementing iterators, always follow the protocol Guido established")
+- Connect design philosophy to practice (e.g., linking "explicit is better than implicit" to your type hinting decisions)
+
+Now let's see how the system has connected your Python development patterns with established best practices:

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-14.py

@@ -0,0 +1,6 @@
+# Search for connections between your async patterns and Python philosophy
+results = await cognee.search(
+    query_text="How does my AsyncWebScraper implementation align with Python's design principles?",
+    datasets=["python-development-with-cognee"],
+)
+print(results)

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-15.md

@@ -0,0 +1,3 @@
+# Temporal Graphs
+
+As we used `temporal_cognify` option for each cognification, we can ask time related questions, for example:

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-16.py

@@ -0,0 +1,7 @@
+result = await cognee.search(
+    query_text="What can we learn from Guido's contributions in 2025?",
+    query_type=cognee.SearchType.TEMPORAL,
+    datasets=["python-development-with-cognee"],
+)
+
+print(result)

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-2.md

@@ -0,0 +1,9 @@
+# What You'll Learn in This Tutorial
+
+In this comprehensive tutorial, you'll discover how to transform scattered development data into an intelligent knowledge system that enhances your coding workflow. By the end, you'll have:
+- Connected disparate data sources (Guido's CPython contributions, mypy development, PEP discussions, your Python projects) into a unified AI memory graph
+- Built a memory layer that understands Python design philosophy, best practice coding patterns, and your preferences and experience
+- Learned how to use intelligent search capabilities that combine the diverse context
+- Integrated everything with your coding environment through MCP (Model Context Protocol)
+
+This tutorial demonstrates the power of knowledge graphs and retrieval-augmented generation (RAG) for software development, showing you how to build systems that learn from Python's creator and improve your own Python development.

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-3.md

@@ -0,0 +1,7 @@
+# Cognee and Its Core Operations
+
+Before we dive in, let's understand the core Cognee operations we'll be working with:
+- `cognee.add()` - Ingests raw data (files, text, APIs) into the system
+- `cognee.cognify()` - Processes and structures data into a knowledge graph using AI
+- `cognee.search()` - Queries the knowledge graph with natural language or Cypher
+- `cognee.memify()` - Cognee's "secret sauce" that infers implicit connections and rules from your data

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-4.md

@@ -0,0 +1,9 @@
+# Data Used in This Tutorial
+
+Cognee can ingest many types of sources. In this tutorial, we use a small, concrete set of files that cover different perspectives:
+
+- `guido_contributions.json` — Authoritative exemplars. Real PRs and commits from Guido van Rossum (mypy, CPython). These show how Python’s creator solved problems and provide concrete anchors for patterns.
+- `pep_style_guide.md` — Norms. Encodes community style and typing conventions (PEP 8 and related). Ensures that search results and inferred rules align with widely accepted standards.
+- `zen_principles.md` — Philosophy The Zen of Python. Grounds design trade‑offs (simplicity, explicitness, readability) beyond syntax or mechanics.
+- `my_developer_rules.md` — Local constraints Your house rules, conventions, and project‑specific requirements (scope, privacy, Spec.md). Keeps recommendations relevant to your actual workflow.
+- `copilot_conversations.json` — Personal history. Transcripts of real assistant conversations, including your questions, code snippets, and discussion topics. Captures “how you code” and connects it to “how Guido codes.”

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-5.md

@@ -0,0 +1,5 @@
+# First Data Ingestion: Exploring Guido's Python Contributions
+
+We'll begin with a document that contains detailed PRs and commits from Guido van Rossum's work on mypy and CPython, showing real-world examples of Python's creator solving type system and language design challenges.
+
+We'll use Cognee's `add()` and `cognify()` functions to ingest this data and build a knowledge graph that connects Guido's development patterns with Python best practices.

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-6.py

@@ -0,0 +1,13 @@
+# Add Guido's contributions to data
+await cognee.add(
+    "d18g11dwdlgfey.cloudfront.net/tutorials/python-development-with-cognee/data/guido_contributions.json",
+    node_set=["guido_data"],
+    dataset_name="python-development-with-cognee",
+)
+
+# Cognify added data into a knowledge graph
+await cognee.cognify(datasets=["python-development-with-cognee"], temporal_cognify=True)
+
+# Search the knowledge graph
+results = await cognee.search("Show me commits", datasets=["python-development-with-cognee"])
+print(results)

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-7.md

@@ -0,0 +1,3 @@
+# What Just Happened?
+
+The `search()` function uses natural language to query a knowledge graph containing Guido's development history. Unlike traditional databases, Cognee understands the relationships between commits, language features, design decisions, and evolution over time.

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-8.md

@@ -0,0 +1,3 @@
+# Ingesting More Data
+
+Now we'll add the remaining data and see how the connections emerge between Guido's contributions, Python best practices, and user conversations.

cognee/modules/notebooks/tutorials/python-development-with-cognee/cell-9.py

@@ -0,0 +1,31 @@
+await cognee.add(
+    "d18g11dwdlgfey.cloudfront.net/tutorials/python-development-with-cognee/data/copilot_conversations.json",
+    node_set=["developer_data"],
+    dataset_name="python-development-with-cognee",
+)
+
+await cognee.add(
+    "d18g11dwdlgfey.cloudfront.net/tutorials/python-development-with-cognee/data/my_developer_rules.md",
+    node_set=["developer_data"],
+    dataset_name="python-development-with-cognee",
+)
+
+await cognee.add(
+    "d18g11dwdlgfey.cloudfront.net/tutorials/python-development-with-cognee/data/zen_principles.md",
+    node_set=["principles_data"],
+    dataset_name="python-development-with-cognee",
+)
+
+await cognee.add(
+    "d18g11dwdlgfey.cloudfront.net/tutorials/python-development-with-cognee/data/pep_style_guide.md",
+    node_set=["principles_data"],
+    dataset_name="python-development-with-cognee",
+)
+
+await cognee.cognify(datasets=["python-development-with-cognee"], temporal_cognify=True)
+
+results = await cognee.search(
+    "What Python type hinting challenges did I face, and how does Guido approach similar problems in mypy?",
+    datasets=["python-development-with-cognee"],
+)
+print(results)

cognee/modules/notebooks/tutorials/python-development-with-cognee/config.json

@@ -0,0 +1,4 @@
+{
+  "name": "Python Development with Cognee - tutorial 🧠",
+  "deletable": false
+}

cognee/modules/notebooks/tutorials/python-development-with-cognee/data/copilot_conversations.json

@@ -0,0 +1,107 @@
+{
+  "conversations": [
+    {
+      "id": "conv_001",
+      "timestamp": "2024-01-15T10:30:00Z",
+      "topic": "async/await patterns",
+      "user_query": "I'm building a web scraper that needs to handle thousands of URLs concurrently. What's the best way to structure this with asyncio?",
+      "assistant_response": "For high-concurrency web scraping, you'll want to use asyncio with aiohttp and implement proper semaphore-based rate limiting. Here's a robust pattern:\n\n```python\nimport asyncio\nimport aiohttp\nfrom typing import List, Dict, Any\n\nclass AsyncWebScraper:\n    def __init__(self, max_concurrent: int = 100):\n        self.semaphore = asyncio.Semaphore(max_concurrent)\n        self.session = None\n    \n    async def __aenter__(self):\n        self.session = aiohttp.ClientSession(\n            timeout=aiohttp.ClientTimeout(total=30),\n            connector=aiohttp.TCPConnector(limit=100)\n        )\n        return self\n    \n    async def __aexit__(self, exc_type, exc_val, exc_tb):\n        if self.session:\n            await self.session.close()\n    \n    async def fetch_url(self, url: str) -> Dict[str, Any]:\n        async with self.semaphore:\n            try:\n                async with self.session.get(url) as response:\n                    content = await response.text()\n                    return {\n                        'url': url,\n                        'status': response.status,\n                        'content': content,\n                        'headers': dict(response.headers)\n                    }\n            except Exception as e:\n                return {'url': url, 'error': str(e)}\n    \n    async def scrape_urls(self, urls: List[str]) -> List[Dict[str, Any]]:\n        tasks = [self.fetch_url(url) for url in urls]\n        return await asyncio.gather(*tasks, return_exceptions=True)\n\n# Usage\nasync def main():\n    urls = ['http://example.com'] * 1000  # Your URLs here\n    \n    async with AsyncWebScraper(max_concurrent=50) as scraper:\n        results = await scraper.scrape_urls(urls)\n        \n    successful = [r for r in results if 'error' not in r]\n    print(f'Successfully scraped {len(successful)} URLs')\n\nif __name__ == '__main__':\n    asyncio.run(main())\n```\n\nKey points:\n- Semaphore controls concurrency to avoid overwhelming servers\n- Context manager ensures proper cleanup\n- TCPConnector with connection pooling\n- Proper exception handling for failed requests",
+      "code_context": {
+        "file": "scraper.py",
+        "language": "python",
+        "patterns_discussed": ["async/await", "context_managers", "semaphores", "aiohttp", "error_handling"]
+      },
+      "follow_up_questions": [
+        "How do I add retry logic for failed requests?",
+        "What's the best way to parse the scraped HTML content?"
+      ]
+    },
+    {
+      "id": "conv_002",
+      "timestamp": "2024-01-16T14:20:00Z",
+      "topic": "dataclass vs pydantic",
+      "user_query": "When should I use dataclasses vs Pydantic models? I'm building an API and need to handle user input validation.",
+      "assistant_response": "Great question! For API development with input validation, here's when to use each:\n\n**Use Pydantic when:**\n- Building APIs (FastAPI, Django REST)\n- Need runtime validation of external data\n- Want automatic JSON serialization/deserialization\n- Need complex validation rules\n- Working with configuration files\n\n**Use dataclasses when:**\n- Internal data structures\n- Simple data containers\n- Want to stay in stdlib\n- Performance is critical (dataclasses are faster)\n\nFor your API, I'd recommend Pydantic:\n\n```python\nfrom pydantic import BaseModel, validator, Field\nfrom typing import Optional, List\nfrom datetime import datetime\nfrom enum import Enum\n\nclass UserRole(str, Enum):\n    ADMIN = 'admin'\n    USER = 'user'\n    GUEST = 'guest'\n\nclass CreateUserRequest(BaseModel):\n    username: str = Field(..., min_length=3, max_length=50, regex=r'^[a-zA-Z0-9_]+$')\n    email: str = Field(..., regex=r'^[\\w\\.-]+@[\\w\\.-]+\\.\\w+$')\n    password: str = Field(..., min_length=8)\n    role: UserRole = UserRole.USER\n    tags: Optional[List[str]] = None\n    \n    @validator('password')\n    def validate_password(cls, v):\n        if not any(c.isupper() for c in v):\n            raise ValueError('Password must contain uppercase letter')\n        if not any(c.isdigit() for c in v):\n            raise ValueError('Password must contain digit')\n        return v\n    \n    @validator('tags')\n    def validate_tags(cls, v):\n        if v and len(v) > 10:\n            raise ValueError('Too many tags')\n        return v\n\nclass User(BaseModel):\n    id: int\n    username: str\n    email: str\n    role: UserRole\n    created_at: datetime\n    is_active: bool = True\n    \n    class Config:\n        orm_mode = True\n        json_encoders = { datetime: lambda v: v.isoformat() }\n\n# FastAPI usage\nfrom fastapi import FastAPI, HTTPException\n\napp = FastAPI()\n\n@app.post('/users/', response_model=User)\nasync def create_user(user_data: CreateUserRequest):\n    try:\n        new_user = await create_user_in_db(user_data)\n        return User.from_orm(new_user)\n    except Exception as e:\n        raise HTTPException(status_code=400, detail=str(e))\n```\n\nPydantic gives you:\n- Automatic request validation\n- Clear error messages\n- Type coercion\n- JSON Schema generation\n- IDE support with type hints",
+      "code_context": {
+        "file": "models.py",
+        "language": "python",
+        "patterns_discussed": ["pydantic", "dataclasses", "validation", "fastapi", "type_hints", "enums"]
+      },
+      "follow_up_questions": [
+        "How do I handle nested validation with Pydantic?",
+        "Can I use Pydantic with SQLAlchemy models?"
+      ]
+    },
+    {
+      "id": "conv_003",
+      "timestamp": "2024-01-17T09:15:00Z",
+      "topic": "testing patterns",
+      "user_query": "I'm struggling with testing async code and database interactions. What's the best approach for pytest with async functions?",
+      "assistant_response": "Testing async code can be tricky! Here's a comprehensive approach using pytest-asyncio and proper test isolation...",
+      "code_context": {
+        "file": "test_users.py",
+        "language": "python",
+        "patterns_discussed": ["pytest", "async_testing", "fixtures", "mocking", "database_testing", "fastapi_testing"]
+      },
+      "follow_up_questions": [
+        "How do I test WebSocket connections?",
+        "What's the best way to test database migrations?"
+      ]
+    },
+    {
+      "id": "conv_004",
+      "timestamp": "2024-01-18T16:45:00Z",
+      "topic": "performance optimization",
+      "user_query": "My FastAPI app is getting slow with large datasets. How can I optimize database queries and response times?",
+      "assistant_response": "Performance optimization in FastAPI apps typically involves several layers...",
+      "code_context": {
+        "file": "optimizations.py",
+        "language": "python",
+        "patterns_discussed": ["performance_optimization", "caching", "database_optimization", "async_patterns", "monitoring"]
+      },
+      "follow_up_questions": [
+        "How do I implement database connection pooling properly?",
+        "What's the best way to handle memory usage with large datasets?"
+      ]
+    },
+    {
+      "id": "conv_005",
+      "timestamp": "2024-01-19T11:30:00Z",
+      "topic": "error handling and logging",
+      "user_query": "I need to implement proper error handling and logging across my Python application. What's the best approach for production-ready error management?",
+      "assistant_response": "Excellent question! Proper error handling and logging are crucial for production applications...",
+      "code_context": {
+        "file": "error_handling.py",
+        "language": "python",
+        "patterns_discussed": ["error_handling", "logging", "exceptions", "middleware", "decorators", "fastapi"]
+      },
+      "follow_up_questions": [
+        "How do I integrate this with external monitoring tools like Sentry?",
+        "What's the best way to handle errors in background tasks?"
+      ]
+    }
+  ],
+  "metadata": {
+    "total_conversations": 5,
+    "date_range": "2024-01-15 to 2024-01-19",
+    "topics_covered": [
+      "async/await patterns",
+      "dataclass vs pydantic",
+      "testing patterns",
+      "performance optimization",
+      "error handling and logging"
+    ],
+    "code_patterns_discussed": [
+      "asyncio", "aiohttp", "semaphores", "context_managers",
+      "pydantic", "fastapi", "type_hints", "validation",
+      "pytest", "async_testing", "fixtures", "mocking",
+      "performance_optimization", "caching", "database_optimization",
+      "error_handling", "logging", "exceptions", "middleware"
+    ],
+    "difficulty_levels": {
+      "beginner": 1,
+      "intermediate": 2,
+      "advanced": 2
+    }
+  }
+}