morphik 0.1.3__tar.gz → 0.1.5__tar.gz

{morphik-0.1.3 → morphik-0.1.5}/.gitignore

@@ -33,7 +33,10 @@ offload/*
 test.pdf
 
 experiments/*
-ui-component/package-lock.json
+ee/ui-component/package-lock.json/*
+ee/ui-component/node-modules/*
+ee/ui-component/.next
 
 
 ui-component/notebook-storage/notebooks.json
+ee/ui-component/package-lock.json

morphik-0.1.5/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: morphik
+Version: 0.1.5
+Summary: Morphik Python Client
+Author-email: Morphik <founders@morphik.ai>
+Requires-Python: >=3.8
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pillow==10.4.0
+Requires-Dist: pydantic==2.10.3
+Requires-Dist: pyjwt>=2.0.0
+Requires-Dist: requests>=2.32.3
+Description-Content-Type: text/markdown
+
+# Morphik
+
+A Python client for Morphik API that enables document ingestion, semantic search, and retrieval augmented generation capabilities.
+
+## Installation
+
+```bash
+pip install morphik
+```
+
+## Usage
+
+The SDK provides both synchronous and asynchronous clients:
+
+### Synchronous Usage
+
+```python
+from morphik import Morphik
+
+# Initialize client - connects to localhost:8000 by default
+db = Morphik()
+
+# Or with authentication URI (for production)
+# db = Morphik("morphik://owner_id:token@api.morphik.ai")
+
+# Ingest a text document
+doc = db.ingest_text(
+    content="Your document content",
+    metadata={"title": "Example Document"}
+)
+
+# Ingest a file
+doc = db.ingest_file(
+    file="path/to/document.pdf",
+    metadata={"category": "reports"}
+)
+
+# Retrieve relevant chunks
+chunks = db.retrieve_chunks(
+    query="Your search query",
+    filters={"category": "reports"}
+)
+
+# Query with RAG
+response = db.query(
+    query="Summarize the key points in the document",
+    filters={"category": "reports"}
+)
+
+print(response.completion)
+```
+
+### Asynchronous Usage
+
+```python
+import asyncio
+from morphik.async_ import AsyncMorphik
+
+async def main():
+    # Initialize async client - connects to localhost:8000 by default
+    async with AsyncMorphik() as db:
+
+    # Or with authentication URI (for production)
+    # async with AsyncMorphik("morphik://owner_id:token@api.morphik.ai") as db:
+        # Ingest a text document
+        doc = await db.ingest_text(
+            content="Your document content",
+            metadata={"title": "Example Document"}
+        )
+
+        # Query with RAG
+        response = await db.query(
+            query="Summarize the key points in the document",
+        )
+
+        print(response.completion)
+
+# Run the async function
+asyncio.run(main())
+```
+
+## Features
+
+- Document ingestion (text, files, directories)
+- Semantic search and retrieval
+- Retrieval-augmented generation (RAG)
+- Knowledge graph creation and querying
+- Multi-user and multi-folder scoping
+- Metadata filtering
+- Document management
+
+## Development
+
+### Running Tests
+
+To run the tests, first install the development dependencies:
+
+```bash
+pip install -r test_requirements.txt
+```
+
+Then run the tests:
+
+```bash
+# Run all tests (requires a running Morphik server)
+pytest morphik/tests/ -v
+
+# Run specific test modules
+pytest morphik/tests/test_sync.py -v
+pytest morphik/tests/test_async.py -v
+
+# Skip tests if you don't have a running server
+SKIP_LIVE_TESTS=1 pytest morphik/tests/ -v
+
+# Specify a custom server URL for tests
+MORPHIK_TEST_URL=http://custom-server:8000 pytest morphik/tests/ -v
+```
+
+### Example Usage Script
+
+The SDK comes with an example script that demonstrates basic usage:
+
+```bash
+# Run synchronous example
+python -m morphik.tests.example_usage
+
+# Run asynchronous example
+python -m morphik.tests.example_usage --async
+```
+
+The example script demonstrates:
+- Text and file ingestion
+- Creating folders and user scopes
+- Retrieving chunks and documents
+- Generating completions using RAG
+- Batch operations and cleanup

morphik-0.1.5/README.md

@@ -0,0 +1,136 @@
+# Morphik
+
+A Python client for Morphik API that enables document ingestion, semantic search, and retrieval augmented generation capabilities.
+
+## Installation
+
+```bash
+pip install morphik
+```
+
+## Usage
+
+The SDK provides both synchronous and asynchronous clients:
+
+### Synchronous Usage
+
+```python
+from morphik import Morphik
+
+# Initialize client - connects to localhost:8000 by default
+db = Morphik()
+
+# Or with authentication URI (for production)
+# db = Morphik("morphik://owner_id:token@api.morphik.ai")
+
+# Ingest a text document
+doc = db.ingest_text(
+    content="Your document content",
+    metadata={"title": "Example Document"}
+)
+
+# Ingest a file
+doc = db.ingest_file(
+    file="path/to/document.pdf",
+    metadata={"category": "reports"}
+)
+
+# Retrieve relevant chunks
+chunks = db.retrieve_chunks(
+    query="Your search query",
+    filters={"category": "reports"}
+)
+
+# Query with RAG
+response = db.query(
+    query="Summarize the key points in the document",
+    filters={"category": "reports"}
+)
+
+print(response.completion)
+```
+
+### Asynchronous Usage
+
+```python
+import asyncio
+from morphik.async_ import AsyncMorphik
+
+async def main():
+    # Initialize async client - connects to localhost:8000 by default
+    async with AsyncMorphik() as db:
+
+    # Or with authentication URI (for production)
+    # async with AsyncMorphik("morphik://owner_id:token@api.morphik.ai") as db:
+        # Ingest a text document
+        doc = await db.ingest_text(
+            content="Your document content",
+            metadata={"title": "Example Document"}
+        )
+
+        # Query with RAG
+        response = await db.query(
+            query="Summarize the key points in the document",
+        )
+
+        print(response.completion)
+
+# Run the async function
+asyncio.run(main())
+```
+
+## Features
+
+- Document ingestion (text, files, directories)
+- Semantic search and retrieval
+- Retrieval-augmented generation (RAG)
+- Knowledge graph creation and querying
+- Multi-user and multi-folder scoping
+- Metadata filtering
+- Document management
+
+## Development
+
+### Running Tests
+
+To run the tests, first install the development dependencies:
+
+```bash
+pip install -r test_requirements.txt
+```
+
+Then run the tests:
+
+```bash
+# Run all tests (requires a running Morphik server)
+pytest morphik/tests/ -v
+
+# Run specific test modules
+pytest morphik/tests/test_sync.py -v
+pytest morphik/tests/test_async.py -v
+
+# Skip tests if you don't have a running server
+SKIP_LIVE_TESTS=1 pytest morphik/tests/ -v
+
+# Specify a custom server URL for tests
+MORPHIK_TEST_URL=http://custom-server:8000 pytest morphik/tests/ -v
+```
+
+### Example Usage Script
+
+The SDK comes with an example script that demonstrates basic usage:
+
+```bash
+# Run synchronous example
+python -m morphik.tests.example_usage
+
+# Run asynchronous example
+python -m morphik.tests.example_usage --async
+```
+
+The example script demonstrates:
+- Text and file ingestion
+- Creating folders and user scopes
+- Retrieving chunks and documents
+- Generating completions using RAG
+- Batch operations and cleanup

{morphik-0.1.3 → morphik-0.1.5}/morphik/__init__.py

@@ -2,9 +2,9 @@
 Morphik Python SDK for document ingestion and querying.
 """
 
-from .sync import Morphik
 from .async_ import AsyncMorphik
 from .models import Document
+from .sync import Morphik
 
 __all__ = [
     "Morphik",
@@ -12,4 +12,4 @@ __all__ = [
     "Document",
 ]
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"

{morphik-0.1.3 → morphik-0.1.5}/morphik/_internal.py

@@ -1,26 +1,25 @@
 import base64
 import io
 import json
-from io import BytesIO, IOBase
-from PIL import Image
-from PIL.Image import Image as PILImage
+from io import BytesIO
 from pathlib import Path
-from typing import Dict, Any, List, Optional, Union, Tuple, BinaryIO
+from typing import Any, BinaryIO, Dict, List, Optional, Tuple, Type, Union
 from urllib.parse import urlparse
 
 import jwt
+from PIL import Image
+from PIL.Image import Image as PILImage
 from pydantic import BaseModel, Field
 
 from .models import (
-    Document,
     ChunkResult,
-    DocumentResult,
+    ChunkSource,  # Prompt override models
     CompletionResponse,
-    IngestTextRequest,
-    ChunkSource,
+    Document,
+    DocumentResult,
     Graph,
-    # Prompt override models
     GraphPromptOverrides,
+    IngestTextRequest,
 )
 from .rules import Rule
 
@@ -199,9 +198,7 @@ class _MorphikClientLogic:
         if rules:
             if all(isinstance(r, list) for r in rules):
                 # List of lists - per-file rules
-                converted_rules = [
-                    [self._convert_rule(r) for r in rule_list] for rule_list in rules
-                ]
+                converted_rules = [[self._convert_rule(r) for r in rule_list] for rule_list in rules]
             else:
                 # Flat list - shared rules for all files
                 converted_rules = [self._convert_rule(r) for r in rules]
@@ -211,7 +208,7 @@ class _MorphikClientLogic:
         data = {
             "metadata": json.dumps(metadata or {}),
             "rules": json.dumps(converted_rules),
-            "use_colpali": str(use_colpali).lower() if use_colpali is not None else None,
+            # use_colpali is a query parameter, not a form field
             "parallel": str(parallel).lower(),
         }
 
@@ -237,6 +234,7 @@ class _MorphikClientLogic:
         prompt_overrides: Optional[Dict],
         folder_name: Optional[str],
         end_user_id: Optional[str],
+        schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
     ) -> Dict[str, Any]:
         """Prepare request for query endpoint"""
         payload = {
@@ -256,6 +254,20 @@ class _MorphikClientLogic:
             payload["folder_name"] = folder_name
         if end_user_id:
             payload["end_user_id"] = end_user_id
+
+        # Add schema to payload if provided
+        if schema:
+            # If schema is a Pydantic model class, serialize it to a JSON schema dict
+            if isinstance(schema, type) and issubclass(schema, BaseModel):
+                payload["schema"] = schema.model_json_schema()
+            elif isinstance(schema, dict):
+                # Basic check if it looks like a JSON schema (has 'properties' or 'type')
+                if "properties" not in schema and "type" not in schema:
+                    raise ValueError("Provided schema dictionary does not look like a valid JSON schema")
+                payload["schema"] = schema
+            else:
+                raise TypeError("schema must be a Pydantic model type or a dictionary representing a JSON schema")
+
         # Filter out None values before sending
         return {k_p: v_p for k_p, v_p in payload.items() if v_p is not None}
 
@@ -361,7 +373,8 @@ class _MorphikClientLogic:
             if end_user_id:
                 request["end_user_id"] = end_user_id
             return request
-        return source_dicts  # Return just sources list if no scoping is needed
+        # Return the dictionary structure { "sources": [...] } consistently.
+        return {"sources": source_dicts}
 
     def _prepare_create_graph_request(
         self,
@@ -454,15 +467,11 @@ class _MorphikClientLogic:
         docs = [Document(**doc) for doc in response_json]
         return docs
 
-    def _parse_document_result_list_response(
-        self, response_json: List[Dict[str, Any]]
-    ) -> List[DocumentResult]:
+    def _parse_document_result_list_response(self, response_json: List[Dict[str, Any]]) -> List[DocumentResult]:
         """Parse document result list response"""
         return [DocumentResult(**r) for r in response_json]
 
-    def _parse_chunk_result_list_response(
-        self, response_json: List[Dict[str, Any]]
-    ) -> List[FinalChunkResult]:
+    def _parse_chunk_result_list_response(self, response_json: List[Dict[str, Any]]) -> List[FinalChunkResult]:
         """Parse chunk result list response"""
         chunks = [ChunkResult(**r) for r in response_json]