trustgraph-base 2.3.18__tar.gz → 2.4.0__tar.gz

{trustgraph_base-2.3.18 → trustgraph_base-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-base
-Version: 2.3.18
+Version: 2.4.0
 Summary: TrustGraph provides a means to run a pipeline of flexible AI processing components in a flexible means to achieve a processing pipeline.
 Author-email: "trustgraph.ai" <security@trustgraph.ai>
 Project-URL: Homepage, https://github.com/trustgraph-ai/trustgraph

{trustgraph_base-2.3.18 → trustgraph_base-2.4.0}/trustgraph/api/__init__.py

@@ -27,7 +27,6 @@ Quick Start:
     # Execute a graph RAG query
     response = flow.graph_rag(
         query="What are the main topics?",
-        user="trustgraph",
         collection="default"
     )
     ```
@@ -38,7 +37,7 @@ For streaming and async operations:
     socket = api.socket()
     flow = socket.flow("default")
 
-    for chunk in flow.agent(question="Hello", user="trustgraph"):
+    for chunk in flow.agent(question="Hello"):
         print(chunk.content)
 
     # Async operations

{trustgraph_base-2.3.18 → trustgraph_base-2.4.0}/trustgraph/api/api.py

@@ -50,7 +50,7 @@ class Api:
         token: Optional bearer token for authentication
     """
 
-    def __init__(self, url="http://localhost:8088/", timeout=60, token: Optional[str] = None):
+    def __init__(self, url="http://localhost:8088/", timeout=60, token: Optional[str] = None, workspace: str = "default"):
         """
         Initialize the TrustGraph API client.
 
@@ -82,6 +82,7 @@ class Api:
 
         self.timeout = timeout
         self.token = token
+        self.workspace = workspace
 
         # Lazy initialization for new clients
         self._socket_client = None
@@ -137,7 +138,7 @@ class Api:
             config.put([ConfigValue(type="llm", key="model", value="gpt-4")])
             ```
         """
-        return Config(api=self)
+        return Config(api=self, workspace=self.workspace)
 
     def knowledge(self):
         """
@@ -151,10 +152,10 @@ class Api:
             knowledge = api.knowledge()
 
             # List available KG cores
-            cores = knowledge.list_kg_cores(user="trustgraph")
+            cores = knowledge.list_kg_cores()
 
             # Load a KG core
-            knowledge.load_kg_core(id="core-123", user="trustgraph")
+            knowledge.load_kg_core(id="core-123")
             ```
         """
         return Knowledge(api=self)
@@ -191,6 +192,12 @@ class Api:
         if self.token:
             headers["Authorization"] = f"Bearer {self.token}"
 
+        # Ensure every REST request carries the workspace so services can
+        # scope their behaviour. Callers that already set workspace in the
+        # payload (e.g. Library client) take precedence.
+        if isinstance(request, dict) and "workspace" not in request:
+            request = {**request, "workspace": self.workspace}
+
         # Invoke the API, input is passed as JSON
         resp = requests.post(url, json=request, timeout=self.timeout, headers=headers)
 
@@ -227,13 +234,12 @@ class Api:
                 document=b"Document content",
                 id="doc-123",
                 metadata=[],
-                user="trustgraph",
                 title="My Document",
                 comments="Test document"
             )
 
             # List documents
-            docs = library.get_documents(user="trustgraph")
+            docs = library.get_documents()
             ```
         """
         return Library(self)
@@ -253,11 +259,10 @@ class Api:
             collection = api.collection()
 
             # List collections
-            colls = collection.list_collections(user="trustgraph")
+            colls = collection.list_collections()
 
             # Update collection metadata
             collection.update_collection(
-                user="trustgraph",
                 collection="default",
                 name="Default Collection",
                 description="Main data collection"
@@ -286,7 +291,6 @@ class Api:
             # Stream agent responses
             for chunk in flow.agent(
                 question="Explain quantum computing",
-                user="trustgraph",
                 streaming=True
             ):
                 if hasattr(chunk, 'content'):
@@ -297,7 +301,10 @@ class Api:
             from . socket_client import SocketClient
             # Extract base URL (remove api/v1/ suffix)
             base_url = self.url.rsplit("api/v1/", 1)[0].rstrip("/")
-            self._socket_client = SocketClient(base_url, self.timeout, self.token)
+            self._socket_client = SocketClient(
+                base_url, self.timeout, self.token,
+                workspace=self.workspace,
+            )
         return self._socket_client
 
     def bulk(self):
@@ -406,7 +413,6 @@ class Api:
             # Stream agent responses
             async for chunk in flow.agent(
                 question="Explain quantum computing",
-                user="trustgraph",
                 streaming=True
             ):
                 if hasattr(chunk, 'content'):
@@ -417,7 +423,10 @@ class Api:
             from . async_socket_client import AsyncSocketClient
             # Extract base URL (remove api/v1/ suffix)
             base_url = self.url.rsplit("api/v1/", 1)[0].rstrip("/")
-            self._async_socket_client = AsyncSocketClient(base_url, self.timeout, self.token)
+            self._async_socket_client = AsyncSocketClient(
+                base_url, self.timeout, self.token,
+                workspace=self.workspace,
+            )
         return self._async_socket_client
 
     def async_bulk(self):

{trustgraph_base-2.3.18 → trustgraph_base-2.4.0}/trustgraph/api/async_flow.py

@@ -326,9 +326,7 @@ class AsyncFlow:
 
             # Use flow services
             result = await flow.graph_rag(
-                query="What is TrustGraph?",
-                user="trustgraph",
-                collection="default"
+                query="What is TrustGraph?",collection="default"
             )
             ```
         """
@@ -385,7 +383,7 @@ class AsyncFlowInstance:
         """
         return await self.flow.request(f"flow/{self.flow_id}/service/{service}", request_data)
 
-    async def agent(self, question: str, user: str, state: Optional[Dict] = None,
+    async def agent(self, question: str, state: Optional[Dict] = None,
                     group: Optional[str] = None, history: Optional[List] = None, **kwargs: Any) -> Dict[str, Any]:
         """
         Execute an agent operation (non-streaming).
@@ -399,7 +397,6 @@ class AsyncFlowInstance:
 
         Args:
             question: User question or instruction
-            user: User identifier
             state: Optional state dictionary for conversation context
             group: Optional group identifier for session management
             history: Optional conversation history list
@@ -416,14 +413,12 @@ class AsyncFlowInstance:
             # Execute agent
             result = await flow.agent(
                 question="What is the capital of France?",
-                user="trustgraph"
-            )
+                )
             print(f"Answer: {result.get('response')}")
             ```
         """
         request_data = {
             "question": question,
-            "user": user,
             "streaming": False  # REST doesn't support streaming
         }
         if state is not None:
@@ -481,7 +476,7 @@ class AsyncFlowInstance:
             model=result.get("model"),
         )
 
-    async def graph_rag(self, query: str, user: str, collection: str,
+    async def graph_rag(self, query: str, collection: str,
                         max_subgraph_size: int = 1000, max_subgraph_count: int = 5,
                         max_entity_distance: int = 3, **kwargs: Any) -> str:
         """
@@ -496,7 +491,6 @@ class AsyncFlowInstance:
 
         Args:
             query: User query text
-            user: User identifier
             collection: Collection identifier containing the knowledge graph
             max_subgraph_size: Maximum number of triples per subgraph (default: 1000)
             max_subgraph_count: Maximum number of subgraphs to retrieve (default: 5)
@@ -513,9 +507,7 @@ class AsyncFlowInstance:
 
             # Query knowledge graph
             response = await flow.graph_rag(
-                query="What are the relationships between these entities?",
-                user="trustgraph",
-                collection="medical-kb",
+                query="What are the relationships between these entities?",collection="medical-kb",
                 max_subgraph_count=3
             )
             print(response)
@@ -523,7 +515,6 @@ class AsyncFlowInstance:
         """
         request_data = {
             "query": query,
-            "user": user,
             "collection": collection,
             "max-subgraph-size": max_subgraph_size,
             "max-subgraph-count": max_subgraph_count,
@@ -535,7 +526,7 @@ class AsyncFlowInstance:
         result = await self.request("graph-rag", request_data)
         return result.get("response", "")
 
-    async def document_rag(self, query: str, user: str, collection: str,
+    async def document_rag(self, query: str, collection: str,
                            doc_limit: int = 10, **kwargs: Any) -> str:
         """
         Execute document-based RAG query (non-streaming).
@@ -549,7 +540,6 @@ class AsyncFlowInstance:
 
         Args:
             query: User query text
-            user: User identifier
             collection: Collection identifier containing documents
             doc_limit: Maximum number of document chunks to retrieve (default: 10)
             **kwargs: Additional service-specific parameters
@@ -564,9 +554,7 @@ class AsyncFlowInstance:
 
             # Query documents
             response = await flow.document_rag(
-                query="What does the documentation say about authentication?",
-                user="trustgraph",
-                collection="docs",
+                query="What does the documentation say about authentication?",collection="docs",
                 doc_limit=5
             )
             print(response)
@@ -574,7 +562,6 @@ class AsyncFlowInstance:
         """
         request_data = {
             "query": query,
-            "user": user,
             "collection": collection,
             "doc-limit": doc_limit,
             "streaming": False
@@ -584,7 +571,7 @@ class AsyncFlowInstance:
         result = await self.request("document-rag", request_data)
         return result.get("response", "")
 
-    async def graph_embeddings_query(self, text: str, user: str, collection: str, limit: int = 10, **kwargs: Any):
+    async def graph_embeddings_query(self, text: str, collection: str, limit: int = 10, **kwargs: Any):
         """
         Query graph embeddings for semantic entity search.
 
@@ -593,7 +580,6 @@ class AsyncFlowInstance:
 
         Args:
             text: Query text for semantic search
-            user: User identifier
             collection: Collection identifier containing graph embeddings
             limit: Maximum number of results to return (default: 10)
             **kwargs: Additional service-specific parameters
@@ -608,9 +594,7 @@ class AsyncFlowInstance:
 
             # Find related entities
             results = await flow.graph_embeddings_query(
-                text="machine learning algorithms",
-                user="trustgraph",
-                collection="tech-kb",
+                text="machine learning algorithms",collection="tech-kb",
                 limit=5
             )
 
@@ -624,7 +608,6 @@ class AsyncFlowInstance:
 
         request_data = {
             "vector": vector,
-            "user": user,
             "collection": collection,
             "limit": limit
         }
@@ -663,7 +646,7 @@ class AsyncFlowInstance:
 
         return await self.request("embeddings", request_data)
 
-    async def triples_query(self, s=None, p=None, o=None, user=None, collection=None, limit=100, **kwargs: Any):
+    async def triples_query(self, s=None, p=None, o=None, collection=None, limit=100, **kwargs: Any):
         """
         Query RDF triples using pattern matching.
 
@@ -674,7 +657,6 @@ class AsyncFlowInstance:
             s: Subject pattern (None for wildcard)
             p: Predicate pattern (None for wildcard)
             o: Object pattern (None for wildcard)
-            user: User identifier (None for all users)
             collection: Collection identifier (None for all collections)
             limit: Maximum number of triples to return (default: 100)
             **kwargs: Additional service-specific parameters
@@ -689,9 +671,7 @@ class AsyncFlowInstance:
 
             # Find all triples with a specific predicate
             results = await flow.triples_query(
-                p="knows",
-                user="trustgraph",
-                collection="social",
+                p="knows",collection="social",
                 limit=50
             )
 
@@ -706,15 +686,13 @@ class AsyncFlowInstance:
             request_data["p"] = str(p)
         if o is not None:
             request_data["o"] = str(o)
-        if user is not None:
-            request_data["user"] = user
         if collection is not None:
             request_data["collection"] = collection
         request_data.update(kwargs)
 
         return await self.request("triples", request_data)
 
-    async def rows_query(self, query: str, user: str, collection: str, variables: Optional[Dict] = None,
+    async def rows_query(self, query: str, collection: str, variables: Optional[Dict] = None,
                          operation_name: Optional[str] = None, **kwargs: Any):
         """
         Execute a GraphQL query on stored rows.
@@ -724,7 +702,6 @@ class AsyncFlowInstance:
 
         Args:
             query: GraphQL query string
-            user: User identifier
             collection: Collection identifier containing rows
             variables: Optional GraphQL query variables
             operation_name: Optional operation name for multi-operation queries
@@ -750,9 +727,7 @@ class AsyncFlowInstance:
             '''
 
             result = await flow.rows_query(
-                query=query,
-                user="trustgraph",
-                collection="users",
+                query=query,collection="users",
                 variables={"status": "active"}
             )
 
@@ -762,7 +737,6 @@ class AsyncFlowInstance:
         """
         request_data = {
             "query": query,
-            "user": user,
             "collection": collection
         }
         if variables:
@@ -774,7 +748,7 @@ class AsyncFlowInstance:
         return await self.request("rows", request_data)
 
     async def row_embeddings_query(
-        self, text: str, schema_name: str, user: str = "trustgraph",
+        self, text: str, schema_name: str,
         collection: str = "default", index_name: Optional[str] = None,
         limit: int = 10, **kwargs: Any
     ):
@@ -788,7 +762,6 @@ class AsyncFlowInstance:
         Args:
             text: Query text for semantic search
             schema_name: Schema name to search within
-            user: User identifier (default: "trustgraph")
             collection: Collection identifier (default: "default")
             index_name: Optional index name to filter search to specific index
             limit: Maximum number of results to return (default: 10)
@@ -806,9 +779,7 @@ class AsyncFlowInstance:
             # Search for customers by name similarity
             results = await flow.row_embeddings_query(
                 text="John Smith",
-                schema_name="customers",
-                user="trustgraph",
-                collection="sales",
+                schema_name="customers",collection="sales",
                 limit=5
             )
 
@@ -823,7 +794,6 @@ class AsyncFlowInstance:
         request_data = {
             "vector": vector,
             "schema_name": schema_name,
-            "user": user,
             "collection": collection,
             "limit": limit
         }

{trustgraph_base-2.3.18 → trustgraph_base-2.4.0}/trustgraph/api/async_socket_client.py

@@ -22,10 +22,14 @@ class AsyncSocketClient:
     Or call connect()/aclose() manually.
     """
 
-    def __init__(self, url: str, timeout: int, token: Optional[str]):
+    def __init__(
+        self, url: str, timeout: int, token: Optional[str],
+        workspace: str = "default",
+    ):
         self.url = self._convert_to_ws_url(url)
         self.timeout = timeout
         self.token = token
+        self.workspace = workspace
         self._request_counter = 0
         self._socket = None
         self._connect_cm = None
@@ -117,6 +121,7 @@ class AsyncSocketClient:
         try:
             message = {
                 "id": request_id,
+                "workspace": self.workspace,
                 "service": service,
                 "request": request
             }
@@ -149,6 +154,7 @@ class AsyncSocketClient:
         try:
             message = {
                 "id": request_id,
+                "workspace": self.workspace,
                 "service": service,
                 "request": request
             }
@@ -251,13 +257,12 @@ class AsyncSocketFlowInstance:
         self.client = client
         self.flow_id = flow_id
 
-    async def agent(self, question: str, user: str, state: Optional[Dict[str, Any]] = None,
+    async def agent(self, question: str, state: Optional[Dict[str, Any]] = None,
                     group: Optional[str] = None, history: Optional[list] = None,
                     streaming: bool = False, **kwargs) -> Union[Dict[str, Any], AsyncIterator]:
         """Agent with optional streaming"""
         request = {
             "question": question,
-            "user": user,
             "streaming": streaming
         }
         if state is not None:
@@ -303,13 +308,12 @@ class AsyncSocketFlowInstance:
             if isinstance(chunk, RAGChunk):
                 yield chunk
 
-    async def graph_rag(self, query: str, user: str, collection: str,
+    async def graph_rag(self, query: str, collection: str,
                         max_subgraph_size: int = 1000, max_subgraph_count: int = 5,
                         max_entity_distance: int = 3, streaming: bool = False, **kwargs):
         """Graph RAG with optional streaming"""
         request = {
             "query": query,
-            "user": user,
             "collection": collection,
             "max-subgraph-size": max_subgraph_size,
             "max-subgraph-count": max_subgraph_count,
@@ -330,12 +334,11 @@ class AsyncSocketFlowInstance:
             if hasattr(chunk, 'content'):
                 yield chunk.content
 
-    async def document_rag(self, query: str, user: str, collection: str,
+    async def document_rag(self, query: str, collection: str,
                            doc_limit: int = 10, streaming: bool = False, **kwargs):
         """Document RAG with optional streaming"""
         request = {
             "query": query,
-            "user": user,
             "collection": collection,
             "doc-limit": doc_limit,
             "streaming": streaming
@@ -375,14 +378,13 @@ class AsyncSocketFlowInstance:
             if hasattr(chunk, 'content'):
                 yield chunk.content
 
-    async def graph_embeddings_query(self, text: str, user: str, collection: str, limit: int = 10, **kwargs):
+    async def graph_embeddings_query(self, text: str, collection: str, limit: int = 10, **kwargs):
         """Query graph embeddings for semantic search"""
         emb_result = await self.embeddings(texts=[text])
         vector = emb_result.get("vectors", [[]])[0]
 
         request = {
             "vector": vector,
-            "user": user,
             "collection": collection,
             "limit": limit
         }
@@ -397,7 +399,7 @@ class AsyncSocketFlowInstance:
 
         return await self.client._send_request("embeddings", self.flow_id, request)
 
-    async def triples_query(self, s=None, p=None, o=None, user=None, collection=None, limit=100, **kwargs):
+    async def triples_query(self, s=None, p=None, o=None, collection=None, limit=100, **kwargs):
         """Triple pattern query"""
         request = {"limit": limit}
         if s is not None:
@@ -406,20 +408,17 @@ class AsyncSocketFlowInstance:
             request["p"] = str(p)
         if o is not None:
             request["o"] = str(o)
-        if user is not None:
-            request["user"] = user
         if collection is not None:
             request["collection"] = collection
         request.update(kwargs)
 
         return await self.client._send_request("triples", self.flow_id, request)
 
-    async def rows_query(self, query: str, user: str, collection: str, variables: Optional[Dict] = None,
+    async def rows_query(self, query: str, collection: str, variables: Optional[Dict] = None,
                          operation_name: Optional[str] = None, **kwargs):
         """GraphQL query against structured rows"""
         request = {
             "query": query,
-            "user": user,
             "collection": collection
         }
         if variables:
@@ -441,7 +440,7 @@ class AsyncSocketFlowInstance:
         return await self.client._send_request("mcp-tool", self.flow_id, request)
 
     async def row_embeddings_query(
-        self, text: str, schema_name: str, user: str = "trustgraph",
+        self, text: str, schema_name: str,
         collection: str = "default", index_name: Optional[str] = None,
         limit: int = 10, **kwargs
     ):
@@ -452,7 +451,6 @@ class AsyncSocketFlowInstance:
         request = {
             "vector": vector,
             "schema_name": schema_name,
-            "user": user,
             "collection": collection,
             "limit": limit
         }

{trustgraph_base-2.3.18 → trustgraph_base-2.4.0}/trustgraph/api/bulk_client.py

@@ -85,7 +85,7 @@ class BulkClient:
         Args:
             flow: Flow identifier
             triples: Iterator yielding Triple objects
-            metadata: Metadata dict with id, metadata, user, collection
+            metadata: Metadata dict with id, metadata, collection
             batch_size: Number of triples per batch (default 100)
             **kwargs: Additional parameters (reserved for future use)
 
@@ -105,7 +105,7 @@ class BulkClient:
             bulk.import_triples(
                 flow="default",
                 triples=triple_generator(),
-                metadata={"id": "doc1", "metadata": [], "user": "user1", "collection": "default"}
+                metadata={"id": "doc1", "metadata": [], "collection": "default"}
             )
             ```
         """
@@ -121,7 +121,7 @@ class BulkClient:
             ws_url = f"{ws_url}?token={self.token}"
 
         if metadata is None:
-            metadata = {"id": "", "metadata": [], "user": "trustgraph", "collection": "default"}
+            metadata = {"id": "", "metadata": [], "collection": "default"}
 
         async with websockets.connect(ws_url, ping_interval=20, ping_timeout=self.timeout) as websocket:
             batch = []
@@ -418,7 +418,7 @@ class BulkClient:
         Args:
             flow: Flow identifier
             contexts: Iterator yielding context dictionaries
-            metadata: Metadata dict with id, metadata, user, collection
+            metadata: Metadata dict with id, metadata, collection
             batch_size: Number of contexts per batch (default 100)
             **kwargs: Additional parameters (reserved for future use)
 
@@ -435,7 +435,7 @@ class BulkClient:
             bulk.import_entity_contexts(
                 flow="default",
                 contexts=context_generator(),
-                metadata={"id": "doc1", "metadata": [], "user": "user1", "collection": "default"}
+                metadata={"id": "doc1", "metadata": [], "collection": "default"}
             )
             ```
         """
@@ -451,7 +451,7 @@ class BulkClient:
             ws_url = f"{ws_url}?token={self.token}"
 
         if metadata is None:
-            metadata = {"id": "", "metadata": [], "user": "trustgraph", "collection": "default"}
+            metadata = {"id": "", "metadata": [], "collection": "default"}
 
         async with websockets.connect(ws_url, ping_interval=20, ping_timeout=self.timeout) as websocket:
             batch = []