fairo 0.1__tar.gz → 25.5.1__tar.gz

{fairo-0.1 → fairo-25.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairo
-Version: 0.1
+Version: 25.5.1
 Summary: SDK for interfacing with Fairo SaaS platform.
 Author-email: "Fairo Systems, Inc." <support@fairo.ai>
 License: Apache-2.0

{fairo-0.1 → fairo-25.5.1}/fairo/core/agent/base_agent.py

@@ -9,10 +9,10 @@ from typing import Dict, List, Optional, Callable, Any, Tuple
 from langchain.schema import HumanMessage, AIMessage, SystemMessage
 from langchain_core.messages import ToolMessage
 from langchain_community.chat_models.mlflow import ChatMlflow
-
+from langchain_core.runnables.config import RunnableConfig
 from fairo.core.agent.output.base_output import BaseOutput
 from fairo.core.agent.tools.base_tools import BaseTool
-from modules.fairo.fairo.core.agent.tools.utils import Iteration, LLMAgentOutput, ToolResult
+from fairo.core.agent.tools.utils import Iteration, LLMAgentOutput, ToolResult
 from langchain_core.messages.tool import ToolCall
 from fairo.core.client.client import BaseClient
 from fairo.core.workflow.dependency import BaseVectorStore
@@ -41,7 +41,8 @@ class SimpleAgent:
             patch_run_output_json: Callable[[LLMAgentOutput], None] = None,
             client: BaseClient = None,
             knowledge_stores: Optional[List[BaseVectorStore]] = None,
-            max_iterations: int = 10
+            max_iterations: int = 10,
+            workflow_run_id: str = "",
     ):
         """
         Initialize the SimpleAgent with its characteristics and capabilities.
@@ -64,9 +65,11 @@ class SimpleAgent:
         self.backstory = backstory
         self.verbose = verbose
         self.use_langchain_mlflow_chat = True if not llm else False
+        self.workflow_run_id = workflow_run_id
         self.llm = llm or ChatMlflow(
             target_uri=get_mlflow_gateway_uri(),
             endpoint=get_mlflow_gateway_chat_route(),
+            extra_params={"workflow_run_id": self.workflow_run_id}
         )
         self.memory = memory or []
         self.conversation_history = []
@@ -470,6 +473,10 @@ class SimpleAgent:
         self.client = client
         for tool in self.tool_instances:
             tool.set_client(client)
+    
+    def set_workflow_run_id(self, workflow_run_id: str):
+        self.set_workflow_run_id = workflow_run_id
+        self.llm.extra_params = {"workflow_run_id": workflow_run_id}
 
     def run(self, task: str, context: Optional[str] = None, max_iterations: int = None) -> str:
         """

{fairo-0.1 → fairo-25.5.1}/fairo/core/execution/executor.py

@@ -18,12 +18,14 @@ class AgentExecutor:
         agents: List[Any],
         verbose: bool = False,
         patch_run_output_json: Callable[[LLMAgentOutput], None] = None,
-        client: BaseClient = None
+        client: BaseClient = None,
+        workflow_run_id: str = ""
     ):
         self.agents = agents
         self.verbose = verbose
         self.patch_run_output_json = patch_run_output_json
         self.client = client
+        self.workflow_run_id = workflow_run_id
 
         # Inject shared attributes into agents
         for agent in self.agents:
@@ -33,6 +35,8 @@ class AgentExecutor:
                 agent.set_client(self.client)
             if hasattr(agent, 'verbose'):
                 agent.verbose = self.verbose
+            if hasattr(agent, 'workflow_run_id'):
+                agent.set_workflow_run_id(self.workflow_run_id)
 
         self.pipeline = self._build_pipeline()
 

{fairo-0.1 → fairo-25.5.1}/fairo/core/workflow/base_workflow.py

@@ -5,7 +5,7 @@ import os
 from enum import Enum
 from typing import List, Union
 from fairo.core.agent.base_agent import SimpleAgent
-from modules.fairo.fairo.core.agent.tools.utils import FlowOutput, LLMAgentOutput
+from fairo.core.agent.tools.utils import FlowOutput, LLMAgentOutput
 from fairo.core.client.client import BaseClient
 
 from fairo.core.execution.executor import AgentExecutor
@@ -223,7 +223,8 @@ class BaseWorkflow:
             agents=self.agents,
             verbose=False,
             patch_run_output_json=self.add_workflow_run_node_output,
-            client=client
+            client=client,
+            workflow_run_id=self.workflow_run_id
         )
 
         # Don't catch exceptions here - let them propagate up to be handled in the run method

fairo-25.5.1/fairo/core/workflow/dependency.py

@@ -0,0 +1,456 @@
+import os
+from typing import Any, Dict, List, Optional, Tuple
+from langchain_aws import BedrockEmbeddings
+from langchain_community.embeddings.mlflow import MlflowEmbeddings
+from langchain_core.documents import Document
+from langchain_postgres import PGVector
+from fairo.settings import get_mlflow_gateway_embeddings_route, get_mlflow_gateway_uri
+from fairo.core.client.client import BaseClient
+AWS_AI_EMBEDDING_MODEL = 'cohere.embed-english-v3'
+import requests
+import uuid
+
+
+class BaseVectorStore:
+    pass
+
+
+class PostgresVectorStore(BaseVectorStore):
+    """
+    A PostgreSQL-based vector store using LangChain and pgvector
+    """
+
+    def __init__(
+            self,
+            collection_name: str,
+            embedding_model_id: str = AWS_AI_EMBEDDING_MODEL,
+            region_name: str = None,
+            collection_metadata: dict = None,
+            connection_string: str = "postgresql://postgres:postgres@localhost:5432/vectordb",
+            pre_delete_collection: bool = False,
+            default_k: int = 5
+    ):
+        """
+        Args:
+            collection_name: Name of the collection in PostgreSQL
+            embedding_model_id: Bedrock embedding model ID
+            region_name: AWS region for Bedrock
+            collection_metadata: Dict for what metadata we want to add to collection
+            connection_string: PostgreSQL connection string
+        """
+        self.collection_name = collection_name
+        self.connection_string = connection_string
+
+        # Set up embeddings
+        self.embeddings = MlflowEmbeddings(
+            target_uri=get_mlflow_gateway_uri(),
+            endpoint=get_mlflow_gateway_embeddings_route(),
+        )
+
+        if collection_metadata is not None:
+            self.collection_metadata = collection_metadata
+
+        # Initialize the PGVector store
+        self.db = PGVector(
+            collection_name=collection_name,
+            connection=connection_string,
+            collection_metadata=self.collection_metadata,
+            embeddings=self.embeddings,
+            pre_delete_collection=pre_delete_collection
+        )
+
+        self.default_k = default_k
+
+    def add_documents(self, documents: List[Document]) -> None:
+        """
+        Args:
+            documents: List of Document objects to add
+        """
+        if not documents:
+            return
+        
+        # Add documents to PGVector
+        self.db.add_documents(documents)
+
+    def add_texts(self, texts: List[str], metadatas: Optional[List[Dict[str, Any]]] = None) -> None:
+        """
+        Args:
+            texts: List of text strings to add
+            metadatas: Optional list of metadata dictionaries
+        """
+        if not texts:
+            return
+
+        # Convert to Document objects
+        documents = []
+        for i, text in enumerate(texts):
+            metadata = metadatas[i] if metadatas and i < len(metadatas) else {}
+            documents.append(Document(page_content=text, metadata=metadata))
+
+        # Add to vector store
+        self.add_documents(documents)
+
+    @staticmethod
+    def _format_query(query):
+        # Temporary fix, need to consider model / do more than truncate
+        return query[0:2048]
+
+    def similarity_search(self, query: str, k: int = None) -> List[Document]:
+        """
+        Args:
+            query: The search query
+            k: Number of results to return
+        """
+        formatted_query = self._format_query(query)
+        if k is None:
+            k = self.default_k
+        return self.db.similarity_search(formatted_query, k=k)
+
+    def similarity_search_with_score(self, query: str, k: int = 4) -> List[tuple[Document, float]]:
+        """
+        Args:
+            query: The search query
+            k: Number of results to return
+        """
+        formatted_query = self._format_query(query)
+        if k is None:
+            k = self.default_k
+        return self.db.similarity_search_with_score(formatted_query, k=k)
+
+    def delete(self) -> None:
+        """Delete the collection from PostgreSQL."""
+        try:
+            # Use the internal PGVector method to delete a collection
+            self.db._client.delete_collection(self.collection_name)
+        except Exception as e:
+            print(f"Error deleting collection: {str(e)}")
+
+    @classmethod
+    def from_existing(cls, 
+                     collection_name: str,
+                     embedding_model_id: str = AWS_AI_EMBEDDING_MODEL,
+                     region_name: str = None,
+                     connection_string: str = "postgresql://postgres:postgres@localhost:5432/vectordb"):
+        """
+        Load an existing collection from PostgreSQL.
+        
+        Args:
+            collection_name: Name of the existing collection
+            embedding_model_id: Bedrock embedding model ID
+            region_name: AWS region for Bedrock
+            connection_string: PostgreSQL connection string
+            
+        Returns:
+            PostgresVectorStore instance connected to the existing collection
+        """
+        return cls(
+            collection_name=collection_name,
+            embedding_model_id=embedding_model_id,
+            region_name=region_name,
+            connection_string=connection_string
+        )
+
+class FairoVectorStore(BaseVectorStore):
+    """
+    A vector store implementation using the Fairo API
+    """
+
+    def __init__(
+            self,
+            collection_name: str,
+            username: str = None,
+            password: str = None,
+            api_url: str = None,
+            embedding_model_id: str = AWS_AI_EMBEDDING_MODEL,
+            region_name: str = None,
+            collection_metadata: dict = None,
+            create_if_not_exists: bool = True
+    ):
+        """
+        Initialize a Fairo vector store client
+        
+        Args:
+            collection_name: Name of the collection
+            username: Fairo API username for authentication
+            password: Fairo API password for authentication
+            api_url: Fairo API base URL
+            embedding_model_id: Bedrock embedding model ID
+            region_name: AWS region for Bedrock
+            collection_metadata: Dict for metadata to add to collection
+            create_if_not_exists: Whether to create the collection if it doesn't exist
+        """
+        self.collection_name = collection_name
+
+        # Get credentials from parameters or environment
+        self.username = username or os.environ.get("FAIRO_API_ACCESS_KEY_ID")
+        self.password = password or os.environ.get("FAIRO_API_SECRET")
+        self.api_url = api_url or os.environ.get("FAIRO_BASE_URL", "https://api.fairo.ai")
+
+        if not self.username or not self.password:
+            raise ValueError("Fairo API credentials must be provided either as parameters or in the FAIRO_USERNAME and FAIRO_PASSWORD environment variables")
+
+        # Initialize API client
+        self.client = BaseClient(
+            base_url=self.api_url.rstrip('/'),
+            username=self.username,
+            password=self.password
+        )
+
+        # Set up embeddings
+        self.embeddings = MlflowEmbeddings(
+            target_uri=get_mlflow_gateway_uri(),
+            endpoint=get_mlflow_gateway_embeddings_route(),
+        )
+
+        self.collection_metadata = collection_metadata or {}
+        self.collection_uuid = None
+
+        # Create or retrieve collection
+        if create_if_not_exists:
+            self._create_or_get_collection()
+
+    def _create_or_get_collection(self) -> None:
+        """
+        Create a new collection or get an existing one by name
+        """
+        try:
+            # First try to find if collection exists
+            collections_data = self.client.get("/collection_stores")
+
+            # Check if our collection exists
+            for collection in collections_data.get("results", []):
+                if collection.get("name") == self.collection_name:
+                    self.collection_uuid = collection.get("uuid")
+                    print(f"Found existing collection '{self.collection_name}' with UUID: {self.collection_uuid}")
+                    return
+
+            # If collection doesn't exist, create a new one
+            if not self.collection_uuid:
+                create_data = {
+                    "name": self.collection_name,
+                    "description": f"Collection for {self.collection_name}",
+                    "cmetadata": self.collection_metadata
+                }
+
+                collection_data = self.client.post("/collection_stores", json=create_data)
+                self.collection_uuid = collection_data.get("uuid")
+                print(f"Created new collection '{self.collection_name}' with UUID: {self.collection_uuid}")
+
+        except requests.exceptions.HTTPError as e:
+            raise Exception(f"Failed to create or get collection: {str(e)}")
+
+    def add_documents(self, documents: List[Document]) -> None:
+        """
+        Add documents to the Fairo vector store
+        
+        Args:
+            documents: List of Document objects to add
+        """
+        if not documents:
+            return
+
+        if not self.collection_uuid:
+            self._create_or_get_collection()
+
+        # Convert documents to Fairo format
+        docs_data = []
+        for doc in documents:
+            # Generate embeddings for the document content
+            embedding = self.embeddings.embed_query(doc.page_content)
+
+            # Create doc entry
+            doc_entry = {
+                "page_content": doc.page_content,
+                "metadata": doc.metadata,
+                "uuid": str(uuid.uuid4())  # Generate a UUID for this document
+            }
+            docs_data.append(doc_entry)
+
+        # Send request to Fairo API
+        try:
+            payload = {"docs": docs_data}
+            self.client.post(f"/collection_stores/{self.collection_uuid}/add_documents", json=payload)
+            print(f"Successfully added {len(documents)} documents to Fairo collection")
+
+        except requests.exceptions.HTTPError as e:
+            raise Exception(f"Failed to add documents: {str(e)}")
+
+    def add_texts(self, texts: List[str], metadatas: Optional[List[Dict[str, Any]]] = None) -> None:
+        """
+        Add texts with optional metadata to the Fairo vector store
+        
+        Args:
+            texts: List of text strings to add
+            metadatas: Optional list of metadata dictionaries
+        """
+        if not texts:
+            return
+
+        # Convert to Document objects
+        documents = []
+        for i, text in enumerate(texts):
+            metadata = metadatas[i] if metadatas and i < len(metadatas) else {}
+            documents.append(Document(page_content=text, metadata=metadata))
+
+        # Add to vector store
+        self.add_documents(documents)
+
+    def similarity_search(self, query: str, k: int = 4) -> List[Document]:
+        """
+        Search for documents similar to the query string
+        
+        Args:
+            query: The search query
+            k: Number of results to return
+            
+        Returns:
+            List of Document objects
+        """
+        # Get search results with scores
+        results_with_scores = self.similarity_search_with_score(query, k=k)
+
+        # Extract just the documents
+        return [doc for doc, _ in results_with_scores]
+
+    def similarity_search_with_score(self, query: str, k: int = 4) -> List[Tuple[Document, float]]:
+        """
+        Search for documents similar to the query string and return scores
+        
+        Args:
+            query: The search query
+            k: Number of results to return
+            
+        Returns:
+            List of (Document, score) tuples
+        """
+        if not self.collection_uuid:
+            self._create_or_get_collection()
+
+        try:
+
+            payload = {
+                "query": query,
+            }
+            if k:
+                payload["k"] = k
+
+            # Send search request
+            search_results = self.client.post(
+                f"/collection_stores/{self.collection_uuid}/similarity_search", 
+                json=payload
+            )
+
+            # Process search results
+            results = []
+
+            for result in search_results:
+                # Create Document object
+                doc = Document(
+                    page_content=result.get("page_content", ""),
+                    metadata=result.get("metadata", {})
+                )
+                score = result.get("score", 0.0)
+                results.append((doc, score))
+
+            return results
+
+        except requests.exceptions.HTTPError as e:
+            raise Exception(f"Search failed: {str(e)}")
+
+    def get_by_id(self, document_id: str) -> Optional[Document]:
+        """
+        Retrieve a document by its ID
+        
+        Args:
+            document_id: The ID of the document to retrieve
+            
+        Returns:
+            Document object if found, None otherwise
+        """
+        if not self.collection_uuid:
+            self._create_or_get_collection()
+
+        try:
+            # In a real implementation, we would likely have a specific endpoint for this
+            # In the absence of that, we'll use a search query with a filter
+
+            # We need to create a filter condition to search by ID
+            # This implementation will depend on how Fairo's API actually handles filters
+            payload = {
+                "filter": {
+                    "metadata": {
+                        "id": document_id
+                    }
+                },
+                "k": 1,
+                "include_text": True,
+                "include_metadata": True
+            }
+
+            # Send request
+            search_results = self.client.post(
+                f"/collection_stores/{self.collection_uuid}/similarity_search",
+                json=payload
+            )
+
+            # Process response
+            results = search_results.get("results", [])
+
+            if not results:
+                return None
+
+            # Create Document from the first result
+            result = results[0]
+            return Document(
+                page_content=result.get("text", ""),
+                metadata=result.get("metadata", {})
+            )
+
+        except requests.exceptions.HTTPError as e:
+            print(f"Error retrieving document by ID: {str(e)}")
+            return None
+
+    def delete(self) -> None:
+        """Delete the collection from Fairo."""
+        if not self.collection_uuid:
+            return
+
+        try:
+            self.client.delete(f"/collection_stores/{self.collection_uuid}")
+            print(f"Collection '{self.collection_name}' deleted successfully")
+            self.collection_uuid = None
+
+        except requests.exceptions.HTTPError as e:
+            print(f"Error deleting collection: {str(e)}")
+
+    @classmethod
+    def from_existing(cls, 
+                     collection_name: str,
+                     username: str = None,
+                     password: str = None,
+                     api_url: str = "https://api.fairo.ai",
+                     embedding_model_id: str = AWS_AI_EMBEDDING_MODEL,
+                     region_name: str = None):
+        """
+        Load an existing collection from Fairo.
+        
+        Args:
+            collection_name: Name of the existing collection
+            username: Fairo API username
+            password: Fairo API password
+            api_url: Fairo API base URL
+            embedding_model_id: Bedrock embedding model ID
+            region_name: AWS region for Bedrock
+            
+        Returns:
+            FairoVectorStore instance connected to the existing collection
+        """
+        return cls(
+            collection_name=collection_name,
+            username=username,
+            password=password,
+            api_url=api_url,
+            embedding_model_id=embedding_model_id,
+            region_name=region_name,
+            create_if_not_exists=False
+        )

{fairo-0.1 → fairo-25.5.1}/fairo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairo
-Version: 0.1
+Version: 25.5.1
 Summary: SDK for interfacing with Fairo SaaS platform.
 Author-email: "Fairo Systems, Inc." <support@fairo.ai>
 License: Apache-2.0

fairo-0.1/fairo/core/workflow/dependency.py

@@ -1,149 +0,0 @@
-from typing import Any, Dict, List, Optional
-from langchain_aws import BedrockEmbeddings
-from langchain_community.embeddings.mlflow import MlflowEmbeddings
-from langchain_core.documents import Document
-from langchain_postgres import PGVector
-
-from fairo.settings import get_mlflow_gateway_embeddings_route, get_mlflow_gateway_uri
-
-AWS_AI_EMBEDDING_MODEL = 'cohere.embed-english-v3'
-
-
-class BaseVectorStore:
-    pass
-
-
-class PostgresVectorStore(BaseVectorStore):
-    """
-    A PostgreSQL-based vector store using LangChain and pgvector
-    """
-
-    def __init__(
-            self,
-            collection_name: str,
-            embedding_model_id: str = AWS_AI_EMBEDDING_MODEL,
-            region_name: str = None,
-            collection_metadata: dict = None,
-            connection_string: str = "postgresql://postgres:postgres@localhost:5432/vectordb",
-            pre_delete_collection: bool = False,
-            default_k: int = 5
-    ):
-        """
-        Args:
-            collection_name: Name of the collection in PostgreSQL
-            embedding_model_id: Bedrock embedding model ID
-            region_name: AWS region for Bedrock
-            collection_metadata: Dict for what metadata we want to add to collection
-            connection_string: PostgreSQL connection string
-        """
-        self.collection_name = collection_name
-        self.connection_string = connection_string
-
-        # Set up embeddings
-        self.embeddings = MlflowEmbeddings(
-            target_uri=get_mlflow_gateway_uri(),
-            endpoint=get_mlflow_gateway_embeddings_route(),
-        )
-
-        if collection_metadata is not None:
-            self.collection_metadata = collection_metadata
-
-        # Initialize the PGVector store
-        self.db = PGVector(
-            collection_name=collection_name,
-            connection=connection_string,
-            collection_metadata=self.collection_metadata,
-            embeddings=self.embeddings,
-            pre_delete_collection=pre_delete_collection
-        )
-
-        self.default_k = default_k
-
-    def add_documents(self, documents: List[Document]) -> None:
-        """
-        Args:
-            documents: List of Document objects to add
-        """
-        if not documents:
-            return
-        
-        # Add documents to PGVector
-        self.db.add_documents(documents)
-
-    def add_texts(self, texts: List[str], metadatas: Optional[List[Dict[str, Any]]] = None) -> None:
-        """
-        Args:
-            texts: List of text strings to add
-            metadatas: Optional list of metadata dictionaries
-        """
-        if not texts:
-            return
-
-        # Convert to Document objects
-        documents = []
-        for i, text in enumerate(texts):
-            metadata = metadatas[i] if metadatas and i < len(metadatas) else {}
-            documents.append(Document(page_content=text, metadata=metadata))
-
-        # Add to vector store
-        self.add_documents(documents)
-
-    @staticmethod
-    def _format_query(query):
-        # Temporary fix, need to consider model / do more than truncate
-        return query[0:2048]
-
-    def similarity_search(self, query: str, k: int = None) -> List[Document]:
-        """
-        Args:
-            query: The search query
-            k: Number of results to return
-        """
-        formatted_query = self._format_query(query)
-        if k is None:
-            k = self.default_k
-        return self.db.similarity_search(formatted_query, k=k)
-
-    def similarity_search_with_score(self, query: str, k: int = 4) -> List[tuple[Document, float]]:
-        """
-        Args:
-            query: The search query
-            k: Number of results to return
-        """
-        formatted_query = self._format_query(query)
-        if k is None:
-            k = self.default_k
-        return self.db.similarity_search_with_score(formatted_query, k=k)
-
-    def delete(self) -> None:
-        """Delete the collection from PostgreSQL."""
-        try:
-            # Use the internal PGVector method to delete a collection
-            self.db._client.delete_collection(self.collection_name)
-        except Exception as e:
-            print(f"Error deleting collection: {str(e)}")
-
-    @classmethod
-    def from_existing(cls, 
-                     collection_name: str,
-                     embedding_model_id: str = AWS_AI_EMBEDDING_MODEL,
-                     region_name: str = None,
-                     connection_string: str = "postgresql://postgres:postgres@localhost:5432/vectordb"):
-        """
-        Load an existing collection from PostgreSQL.
-        
-        Args:
-            collection_name: Name of the existing collection
-            embedding_model_id: Bedrock embedding model ID
-            region_name: AWS region for Bedrock
-            connection_string: PostgreSQL connection string
-            
-        Returns:
-            PostgresVectorStore instance connected to the existing collection
-        """
-        return cls(
-            collection_name=collection_name,
-            embedding_model_id=embedding_model_id,
-            region_name=region_name,
-            connection_string=connection_string
-        )