morphik 0.1.8__tar.gz → 0.2.0__tar.gz

{morphik-0.1.8 → morphik-0.2.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: morphik
-Version: 0.1.8
+Version: 0.2.0
 Summary: Morphik Python Client
 Author-email: Morphik <founders@morphik.ai>
 Requires-Python: >=3.8
 Requires-Dist: build>=1.2.2.post1
 Requires-Dist: httpx>=0.24.0
-Requires-Dist: pillow==10.4.0
-Requires-Dist: pydantic==2.10.3
+Requires-Dist: pillow>=10.4.0
+Requires-Dist: pydantic>=2.10.3
 Requires-Dist: pyjwt>=2.0.0
 Requires-Dist: requests>=2.32.3
 Requires-Dist: twine>=6.1.0

{morphik-0.1.8 → morphik-0.2.0}/morphik/_internal.py

@@ -172,8 +172,14 @@ class _MorphikClientLogic:
         rules: Optional[List[RuleOrDict]],
         folder_name: Optional[str],
         end_user_id: Optional[str],
+        use_colpali: Optional[bool] = None,
     ) -> Dict[str, Any]:
-        """Prepare form data for ingest_file endpoint"""
+        """Prepare form data for ingest_file endpoint.
+
+        All parameters are included in the multipart body so that the server
+        never relies on query-string values.  *use_colpali* is therefore always
+        embedded here when provided.
+        """
         form_data = {
             "metadata": json.dumps(metadata or {}),
             "rules": json.dumps([self._convert_rule(r) for r in (rules or [])]),
@@ -182,6 +188,12 @@ class _MorphikClientLogic:
             form_data["folder_name"] = folder_name
         if end_user_id:
             form_data["end_user_id"] = end_user_id
+
+        # Only include the flag when caller supplied a specific value to avoid
+        # overriding server defaults unintentionally.
+        if use_colpali is not None:
+            form_data["use_colpali"] = str(use_colpali).lower()
+
         return form_data
 
     def _prepare_ingest_files_form_data(
@@ -208,10 +220,15 @@ class _MorphikClientLogic:
         data = {
             "metadata": json.dumps(metadata or {}),
             "rules": json.dumps(converted_rules),
-            # use_colpali is a query parameter, not a form field
             "parallel": str(parallel).lower(),
         }
 
+        # Always carry use_colpali in the body for consistency with single-file
+        # ingestion.  The API treats missing values as "true" for backward
+        # compatibility, hence we only add it when explicitly provided.
+        if use_colpali is not None:
+            data["use_colpali"] = str(use_colpali).lower()
+
         if folder_name:
             data["folder_name"] = folder_name
         if end_user_id:
@@ -234,6 +251,7 @@ class _MorphikClientLogic:
         prompt_overrides: Optional[Dict],
         folder_name: Optional[Union[str, List[str]]],
         end_user_id: Optional[str],
+        chat_id: Optional[str] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
     ) -> Dict[str, Any]:
         """Prepare request for query endpoint"""
@@ -254,6 +272,8 @@ class _MorphikClientLogic:
             payload["folder_name"] = folder_name
         if end_user_id:
             payload["end_user_id"] = end_user_id
+        if chat_id:
+            payload["chat_id"] = chat_id
 
         # Add schema to payload if provided
         if schema:

{morphik-0.1.8 → morphik-0.2.0}/morphik/async_.py

@@ -163,14 +163,15 @@ class AsyncFolder:
             files = {"file": (filename, file_obj)}
 
             # Create form data
-            form_data = self._client._logic._prepare_ingest_file_form_data(metadata, rules, self._name, None)
+            form_data = self._client._logic._prepare_ingest_file_form_data(
+                metadata, rules, self._name, None, use_colpali
+            )
 
             response = await self._client._request(
                 "POST",
                 "ingest/file",
                 data=form_data,
                 files=files,
-                params={"use_colpali": str(use_colpali).lower()},
             )
             doc = self._client._logic._parse_document_response(response)
             doc._client = self._client
@@ -215,7 +216,6 @@ class AsyncFolder:
                 "ingest/files",
                 data=data,
                 files=file_objects,
-                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -354,6 +354,7 @@ class AsyncFolder:
         prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
         additional_folders: Optional[List[str]] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
+        chat_id: Optional[str] = None,
     ) -> CompletionResponse:
         """
         Generate completion using relevant chunks as context within this folder.
@@ -391,6 +392,7 @@ class AsyncFolder:
             prompt_overrides,
             effective_folder,
             None,
+            chat_id,
             schema,
         )
 
@@ -474,9 +476,7 @@ class AsyncFolder:
             List[FinalChunkResult]: List of chunk results
         """
         merged = self._merge_folders(additional_folders)
-        request = self._client._logic._prepare_batch_get_chunks_request(
-            sources, merged, None, use_colpali
-        )
+        request = self._client._logic._prepare_batch_get_chunks_request(sources, merged, None, use_colpali)
         response = await self._client._request("POST", "batch/chunks", data=request)
         return self._client._logic._parse_chunk_result_list_response(response)
 
@@ -670,14 +670,14 @@ class AsyncUserScope:
             # Prepare multipart form data
             files = {"file": (filename, file_obj)}
 
-            # Add metadata and rules
+            # Add metadata, rules and scoping information
             data = {
                 "metadata": json.dumps(metadata or {}),
                 "rules": json.dumps([self._client._convert_rule(r) for r in (rules or [])]),
-                "end_user_id": self._end_user_id,  # Add end user ID here
+                "end_user_id": self._end_user_id,
+                "use_colpali": str(use_colpali).lower(),
             }
 
-            # Add folder name if scoped to a folder
             if self._folder_name:
                 data["folder_name"] = self._folder_name
 
@@ -738,9 +738,9 @@ class AsyncUserScope:
             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,
                 "parallel": str(parallel).lower(),
-                "end_user_id": self._end_user_id,  # Add end user ID here
+                "end_user_id": self._end_user_id,
+                "use_colpali": str(use_colpali).lower(),
             }
 
             # Add folder name if scoped to a folder
@@ -752,7 +752,6 @@ class AsyncUserScope:
                 "ingest/files",
                 data=data,
                 files=file_objects,
-                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -891,6 +890,7 @@ class AsyncUserScope:
         prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
         additional_folders: Optional[List[str]] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
+        chat_id: Optional[str] = None,
     ) -> CompletionResponse:
         """
         Generate completion using relevant chunks as context, scoped to the end user.
@@ -928,6 +928,7 @@ class AsyncUserScope:
             prompt_overrides,
             effective_folder,
             self._end_user_id,
+            chat_id,
             schema,
         )
 
@@ -1345,14 +1346,13 @@ class AsyncMorphik:
             files = {"file": (filename, file_obj)}
 
             # Create form data
-            form_data = self._logic._prepare_ingest_file_form_data(metadata, rules, None, None)
+            form_data = self._logic._prepare_ingest_file_form_data(metadata, rules, None, None, use_colpali)
 
             response = await self._request(
                 "POST",
                 "ingest/file",
                 data=form_data,
                 files=files,
-                params={"use_colpali": str(use_colpali).lower()},
             )
             doc = self._logic._parse_document_response(response)
             doc._client = self
@@ -1398,7 +1398,6 @@ class AsyncMorphik:
                 "ingest/files",
                 data=data,
                 files=file_objects,
-                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -1554,6 +1553,7 @@ class AsyncMorphik:
         include_paths: bool = False,
         prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
         folder_name: Optional[Union[str, List[str]]] = None,
+        chat_id: Optional[str] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
     ) -> CompletionResponse:
         """
@@ -1659,6 +1659,7 @@ class AsyncMorphik:
             prompt_overrides,
             effective_folder,
             None,
+            chat_id,
             schema,
         )
 
@@ -1676,6 +1677,45 @@ class AsyncMorphik:
         response = await self._request("POST", "query", data=payload)
         return self._logic._parse_completion_response(response)
 
+    async def agent_query(self, query: str) -> Dict[str, Any]:
+        """
+        Execute an agentic query with tool access and conversation handling.
+
+        The agent can autonomously use various tools to answer complex queries including:
+        - Searching and retrieving relevant documents
+        - Analyzing document content 
+        - Performing calculations and data processing
+        - Creating summaries and reports
+        - Managing knowledge graphs
+
+        Args:
+            query: Natural language query for the Morphik agent
+
+        Returns:
+            Dict[str, Any]: Agent response with potential tool execution results and sources
+
+        Example:
+            ```python
+            # Simple query
+            result = await db.agent_query("What are the main trends in our Q3 sales data?")
+            print(result["response"])
+
+            # Complex analysis request
+            result = await db.agent_query(
+                "Analyze all documents from the marketing department, "
+                "identify key performance metrics, and create a summary "
+                "with actionable insights"
+            )
+            print(result["response"])
+
+            # Tool usage is automatic - the agent will decide which tools to use
+            # based on the query requirements
+            ```
+        """
+        request = {"query": query}
+        response = await self._request("POST", "agent", data=request)
+        return response
+
     async def list_documents(
         self,
         skip: int = 0,
@@ -2225,9 +2265,7 @@ class AsyncMorphik:
                 print(f"Chunk from {chunk.document_id}, number {chunk.chunk_number}: {chunk.content[:50]}...")
             ```
         """
-        request = self._logic._prepare_batch_get_chunks_request(
-            sources, folder_name, None, use_colpali
-        )
+        request = self._logic._prepare_batch_get_chunks_request(sources, folder_name, None, use_colpali)
         response = await self._request("POST", "batch/chunks", data=request)
         return self._logic._parse_chunk_result_list_response(response)
 

{morphik-0.1.8 → morphik-0.2.0}/morphik/sync.py

@@ -163,15 +163,16 @@ class Folder:
             files = {"file": (filename, file_obj)}
 
             # Create form data
-            form_data = self._client._logic._prepare_ingest_file_form_data(metadata, rules, self._name, None)
+            form_data = self._client._logic._prepare_ingest_file_form_data(
+                metadata, rules, self._name, None, use_colpali
+            )
 
-            # use_colpali should be a query parameter as defined in the API
+            # use_colpali flag is included in multipart form data for consistency
             response = self._client._request(
                 "POST",
                 "ingest/file",
                 data=form_data,
                 files=files,
-                params={"use_colpali": str(use_colpali).lower()},
             )
             doc = self._client._logic._parse_document_response(response)
             doc._client = self._client
@@ -216,7 +217,6 @@ class Folder:
                 "ingest/files",
                 data=data,
                 files=file_objects,
-                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -367,6 +367,7 @@ class Folder:
         prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
         additional_folders: Optional[List[str]] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
+        chat_id: Optional[str] = None,
     ) -> CompletionResponse:
         """
         Generate completion using relevant chunks as context within this folder.
@@ -404,6 +405,7 @@ class Folder:
             prompt_overrides,
             effective_folder,
             None,  # end_user_id not supported at this level
+            chat_id,
             schema,
         )
 
@@ -488,9 +490,7 @@ class Folder:
             List[FinalChunkResult]: List of chunk results
         """
         merged = self._merge_folders(additional_folders)
-        request = self._client._logic._prepare_batch_get_chunks_request(
-            sources, merged, None, use_colpali
-        )
+        request = self._client._logic._prepare_batch_get_chunks_request(sources, merged, None, use_colpali)
 
         response = self._client._request("POST", "batch/chunks", data=request)
         return self._client._logic._parse_chunk_result_list_response(response)
@@ -703,24 +703,22 @@ class UserScope:
             # Prepare multipart form data
             files = {"file": (filename, file_obj)}
 
-            # Add metadata and rules
+            # Add metadata, rules and scoping information
             form_data = {
                 "metadata": json.dumps(metadata or {}),
                 "rules": json.dumps([self._client._convert_rule(r) for r in (rules or [])]),
-                "end_user_id": self._end_user_id,  # Add end user ID here
+                "end_user_id": self._end_user_id,
+                "use_colpali": str(use_colpali).lower(),
             }
 
-            # Add folder name if scoped to a folder
             if self._folder_name:
                 form_data["folder_name"] = self._folder_name
 
-            # use_colpali should be a query parameter as defined in the API
             response = self._client._request(
                 "POST",
                 "ingest/file",
                 data=form_data,
                 files=files,
-                params={"use_colpali": str(use_colpali).lower()},
             )
             doc = self._client._logic._parse_document_response(response)
             doc._client = self._client
@@ -778,9 +776,9 @@ class UserScope:
             data = {
                 "metadata": json.dumps(metadata or {}),
                 "rules": json.dumps(converted_rules),
-                # Remove use_colpali from form data - it should be a query param
                 "parallel": str(parallel).lower(),
                 "end_user_id": self._end_user_id,  # Add end user ID here
+                "use_colpali": str(use_colpali).lower(),
             }
 
             # Add folder name if scoped to a folder
@@ -792,7 +790,6 @@ class UserScope:
                 "ingest/files",
                 data=data,
                 files=file_objects,
-                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -953,6 +950,7 @@ class UserScope:
         prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
         additional_folders: Optional[List[str]] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
+        chat_id: Optional[str] = None,
     ) -> CompletionResponse:
         """
         Generate completion using relevant chunks as context as this end user.
@@ -990,6 +988,7 @@ class UserScope:
             prompt_overrides,
             effective_folder,
             self._end_user_id,
+            chat_id,
             schema,
         )
 
@@ -1088,9 +1087,7 @@ class UserScope:
             List[FinalChunkResult]: List of chunk results
         """
         merged = self._merge_folders(additional_folders)
-        request = self._client._logic._prepare_batch_get_chunks_request(
-            sources, merged, None, use_colpali
-        )
+        request = self._client._logic._prepare_batch_get_chunks_request(sources, merged, None, use_colpali)
 
         response = self._client._request("POST", "batch/chunks", data=request)
         return self._client._logic._parse_chunk_result_list_response(response)
@@ -1493,7 +1490,7 @@ class Morphik:
             files = {"file": (filename, file_obj)}
 
             # Create form data
-            form_data = self._logic._prepare_ingest_file_form_data(metadata, rules, None, None)
+            form_data = self._logic._prepare_ingest_file_form_data(metadata, rules, None, None, use_colpali)
 
             # use_colpali should be a query parameter as defined in the API
             response = self._request(
@@ -1501,7 +1498,6 @@ class Morphik:
                 "ingest/file",
                 data=form_data,
                 files=files,
-                params={"use_colpali": str(use_colpali).lower()},
             )
             doc = self._logic._parse_document_response(response)
             doc._client = self
@@ -1548,7 +1544,6 @@ class Morphik:
                 "ingest/files",
                 data=data,
                 files=file_objects,
-                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -1701,6 +1696,7 @@ class Morphik:
         include_paths: bool = False,
         prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
         folder_name: Optional[Union[str, List[str]]] = None,
+        chat_id: Optional[str] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
     ) -> CompletionResponse:
         """
@@ -1807,6 +1803,7 @@ class Morphik:
             prompt_overrides,
             folder_name,
             None,  # end_user_id not supported at this level
+            chat_id,
             schema,
         )
 
@@ -1824,6 +1821,45 @@ class Morphik:
         response = self._request("POST", "query", data=payload)
         return self._logic._parse_completion_response(response)
 
+    def agent_query(self, query: str) -> Dict[str, Any]:
+        """
+        Execute an agentic query with tool access and conversation handling.
+
+        The agent can autonomously use various tools to answer complex queries including:
+        - Searching and retrieving relevant documents
+        - Analyzing document content 
+        - Performing calculations and data processing
+        - Creating summaries and reports
+        - Managing knowledge graphs
+
+        Args:
+            query: Natural language query for the Morphik agent
+
+        Returns:
+            Dict[str, Any]: Agent response with potential tool execution results and sources
+
+        Example:
+            ```python
+            # Simple query
+            result = db.agent_query("What are the main trends in our Q3 sales data?")
+            print(result["response"])
+
+            # Complex analysis request
+            result = db.agent_query(
+                "Analyze all documents from the marketing department, "
+                "identify key performance metrics, and create a summary "
+                "with actionable insights"
+            )
+            print(result["response"])
+
+            # Tool usage is automatic - the agent will decide which tools to use
+            # based on the query requirements
+            ```
+        """
+        request = {"query": query}
+        response = self._request("POST", "agent", data=request)
+        return response
+
     def list_documents(
         self,
         skip: int = 0,
@@ -2368,9 +2404,7 @@ class Morphik:
                 print(f"Chunk from {chunk.document_id}, number {chunk.chunk_number}: {chunk.content[:50]}...")
             ```
         """
-        request = self._logic._prepare_batch_get_chunks_request(
-            sources, folder_name, None, use_colpali
-        )
+        request = self._logic._prepare_batch_get_chunks_request(sources, folder_name, None, use_colpali)
         response = self._request("POST", "batch/chunks", data=request)
         return self._logic._parse_chunk_result_list_response(response)
 

{morphik-0.1.8 → morphik-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "morphik"
-version = "0.1.8"
+version = "0.2.0"
 authors = [
     { name = "Morphik", email = "founders@morphik.ai" },
 ]
@@ -14,9 +14,9 @@ requires-python = ">=3.8"
 dependencies = [
     "httpx>=0.24.0",
     "pyjwt>=2.0.0",
-    "pydantic==2.10.3",
+    "pydantic>=2.10.3",
     "requests>=2.32.3",
-    "pillow==10.4.0",
+    "pillow>=10.4.0",
     "build>=1.2.2.post1",
     "twine>=6.1.0",
 ]