fairo 25.8.2__tar.gz → 25.9.2__tar.gz

{fairo-25.8.2 → fairo-25.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairo
-Version: 25.8.2
+Version: 25.9.2
 Summary: SDK for interfacing with Fairo SaaS platform.
 Author-email: "Fairo Systems, Inc." <support@fairo.ai>
 License: Apache-2.0
@@ -11,14 +11,12 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
-Requires-Dist: mlflow<=3.2.0,>=3.1.0
+Requires-Dist: mlflow<=3.1.1,>=3.1.0
 Requires-Dist: langchain<0.4.0,>=0.3.20
 Requires-Dist: langchain-aws<0.3.0,>=0.2.18
 Requires-Dist: langchain-community<0.4.0,>=0.3.20
 Requires-Dist: langchain-core<0.4.0,>=0.3.49
 Requires-Dist: langchain-text-splitters<0.4.0,>=0.3.7
-Requires-Dist: psycopg2-binary<3.0.0,>=2.9.0
-Requires-Dist: langchain-postgres<0.1.0,>=0.0.14
 Requires-Dist: setuptools>=79.0.0
 Requires-Dist: pandas<3.0.0,>=2.0.0
 

fairo-25.9.2/fairo/__init__.py

@@ -0,0 +1 @@
+__version__ = "25.9.2"

{fairo-25.8.2 → fairo-25.9.2}/fairo/core/chat/chat.py

@@ -31,10 +31,10 @@ class FairoDeploymentClient(BaseDeploymentClient):
         
         # Add authentication if needed
         auth = None
-        if os.environ.get('MLFLOW_TRACKING_USERNAME') and os.environ.get('MLFLOW_TRACKING_PASSWORD'):
+        if os.environ.get('FAIRO_API_ACCESS_KEY_ID') and os.environ.get('FAIRO_API_SECRET'):
             auth = HTTPBasicAuth(
-                os.environ.get('MLFLOW_TRACKING_USERNAME'),
-                os.environ.get('MLFLOW_TRACKING_PASSWORD')
+                os.environ.get('FAIRO_API_ACCESS_KEY_ID'),
+                os.environ.get('FAIRO_API_SECRET')
             )
         
         # Make streaming request
@@ -116,10 +116,10 @@ class FairoDeploymentClient(BaseDeploymentClient):
         
         # Add authentication if needed
         auth = None
-        if os.environ.get('MLFLOW_TRACKING_USERNAME') and os.environ.get('MLFLOW_TRACKING_PASSWORD'):
+        if os.environ.get('FAIRO_API_ACCESS_KEY_ID') and os.environ.get('FAIRO_API_SECRET'):
             auth = HTTPBasicAuth(
-                os.environ.get('MLFLOW_TRACKING_USERNAME'),
-                os.environ.get('MLFLOW_TRACKING_PASSWORD')
+                os.environ.get('FAIRO_API_ACCESS_KEY_ID'),
+                os.environ.get('FAIRO_API_SECRET')
             )
         
         if os.environ.get('MLFLOW_TRACKING_TOKEN'):
@@ -183,10 +183,6 @@ class ChatFairo(ChatMlflow):
 
     def __init__(self, **kwargs):
 
-        # # TODO <- see if this can be improved
-        # os.environ["MLFLOW_TRACKING_USERNAME"] = get_mlflow_user()
-        # os.environ["MLFLOW_TRACKING_PASSWORD"] = get_mlflow_password()
-
         super().__init__(
             target_uri=os.environ.get('MLFLOW_GATEWAY_URI', get_mlflow_gateway_uri()),
             endpoint=os.environ.get('MLFLOW_GATEWAY_ROUTE', get_mlflow_gateway_chat_route()),
@@ -197,11 +193,11 @@ class ChatFairo(ChatMlflow):
 
     @property
     def _target_uri(self):
-        return os.environ.get("MLFLOW_GATEWAY_URI", None)
+        return os.environ.get("MLFLOW_GATEWAY_URI", get_mlflow_gateway_uri())
 
     @property
     def _endpoint(self):
-        return os.environ.get("MLFLOW_GATEWAY_ROUTE", None)
+        return os.environ.get("MLFLOW_GATEWAY_ROUTE", get_mlflow_gateway_chat_route())
 
     def invoke(self, *args, **kwargs):
         # Override invoke to use dynamic target_uri

{fairo-25.8.2 → fairo-25.9.2}/fairo/core/execution/executor.py

@@ -1,10 +1,12 @@
 import json
 import os
-from typing import List, Any, Callable, Dict, Union
+from typing import List, Any, Callable, Dict, Optional, Type, Union
 from langchain_core.runnables import RunnableLambda, RunnableSequence
 from langchain.chains import SimpleSequentialChain
 import logging
 
+from pydantic import BaseModel
+
 import mlflow
 
 from mlflow.models.signature import ModelSignature
@@ -16,14 +18,13 @@ from fairo.core.execution.model_log_helper import ModelLogHelper
 from fairo.core.runnable.runnable import Runnable
 from fairo.core.workflow.utils import output_langchain_process_graph
 from fairo.settings import get_fairo_api_key, get_fairo_api_secret, get_mlflow_experiment_name, get_mlflow_server, get_fairo_base_url
-
+from fairo.core.tools import ChatSuggestions
 
 logger = logging.getLogger(__name__)
 
 class FairoExecutor:
     def __init__(
         self,
-        input_schema,
         agent_type: str = "Langchain",
         agents: List[Any] = [],
         verbose: bool = False,
@@ -33,11 +34,13 @@ class FairoExecutor:
         experiment_name: str = None,
         chain_class = SimpleSequentialChain,
         input_fields: List[str] = [],
+        input_schema: Optional[Type[BaseModel]] = None,
+        chat_suggestions: Optional[ChatSuggestions] = None
     ):
         if agents and runnable:
             raise ValueError("FairoExecutor cannot be initialized with both 'agents' and 'runnable'. Please provide only one.")
-        if not input_fields:
-            raise ValueError("Missing input_fields")
+        if not input_fields and not input_schema:
+            raise ValueError("Missing required parameters: please provide at least one of 'input_fields' or 'input_schema'")
         self.input_schema = input_schema
         self.agents = agents
         self.agent_type = agent_type
@@ -53,6 +56,7 @@ class FairoExecutor:
             password=get_fairo_api_secret(),
             username=get_fairo_api_key()
         )
+        self.chat_suggestions = chat_suggestions
         self.input_fields = input_fields
         # Inject shared attributes into agents
         for agent in self.agents:
@@ -117,8 +121,9 @@ class FairoExecutor:
             fairo_settings = {
                 "type": type,
                 "process_graph": process_graph,
-                "schema": self.input_schema.model_json_schema(),
-                "input_fields": list(self.input_schema.model_fields.keys()),
+                "schema": self.input_schema.model_json_schema() if self.input_schema else None,
+                "input_fields": list(self.input_schema.model_fields.keys()) if self.input_schema else self.input_fields,
+                "chat_suggestions": self.chat_suggestions.model_dump() if self.chat_suggestions else None,
             }
             if process_graph:
                 mlflow.log_text(json.dumps(fairo_settings, ensure_ascii=False, indent=2), artifact_file="fairo_settings.txt")

fairo-25.9.2/fairo/core/tools/__init__.py

@@ -0,0 +1,2 @@
+from .plot import generate_plot
+from .suggestion import send_chat_suggestions, ChatSuggestions, ChatSuggestion

fairo-25.9.2/fairo/core/tools/plot.py

@@ -0,0 +1,229 @@
+from typing import Dict, List, Literal, Optional, Union
+from pydantic import BaseModel, Field, ConfigDict
+from enum import Enum
+from langchain_core.tools import tool
+import matplotlib
+matplotlib.use("Agg")  # headless
+import matplotlib.pyplot as plt
+import io
+import base64
+
+class ChartTypeEnum(str, Enum):
+    line = "line"
+    bar = "bar"
+    scatter = "scatter"
+    hist = "hist"
+    area = "area"
+
+EXAMPLES = [
+    {
+        "chart_type": "line",
+        "data": {"month": ["Jan","Feb","Mar"], "revenue": [10, 12, 15]},
+        "x": "month",
+        "y": "revenue",
+        "title": "Revenue by Month"
+    },
+    {
+        "chart_type": "bar",
+        "data": {"cat": ["A","B"], "m1": [1,2], "m2":[2,1]},
+        "x": "cat",
+        "y": ["m1","m2"],
+        "title": "Grouped Bars"
+    }
+]
+
+class PlotSpec(BaseModel):
+    """
+    Either provide a 'spec' for a chart OR provide 'python_code' to execute.
+
+    If you provide 'spec', set:
+      - chart_type: one of line|bar|scatter|hist|area
+      - data: list of dicts (table rows) OR {"x":[...], "y":[...]} arrays
+      - x: x key (for list-of-dicts) or leave None if arrays
+      - y: y key or list of keys for multi-series
+      - title, xlabel, ylabel: optional labels
+      - width, height in inches (optional)
+    If you provide 'python_code', it must create a 'fig' and 'ax' variable.
+    """
+    model_config = ConfigDict(extra="allow", json_schema_extra={"examples": EXAMPLES})
+
+    # Option A: high-level specification
+    chart_type: Optional[ChartTypeEnum] = Field(None, description="Chart type.")
+    data: Optional[Union[List[Dict], Dict[str, List]]] = Field(
+        None, description="Either list of dict rows OR dict of arrays."
+    )
+    x: Optional[Union[str, List[str]]] = Field(None, description="X column or key(s).")
+    y: Optional[Union[str, List[str]]] = Field(None, description="Y column or key(s).")
+    title: Optional[str] = None
+    xlabel: Optional[str] = None
+    ylabel: Optional[str] = None
+    width: Optional[float] = Field(6.0, description="Figure width in inches.")
+    height: Optional[float] = Field(4.0, description="Figure height in inches.")
+    legend: Optional[bool] = True
+    grid: Optional[bool] = True
+    alpha: Optional[float] = 1.0
+
+    # Option B: low-level custom code (SAFE-ish)
+    python_code: Optional[str] = Field(
+        None,
+        description=(
+            "Matplotlib code that defines 'fig, ax'. Avoid imports; "
+            "numpy is available as 'np' and matplotlib.pyplot as 'plt'."
+        ),
+    )
+
+
+def _png_base64_from_fig(fig) -> str:
+    buf = io.BytesIO()
+    fig.savefig(buf, format="png", dpi=150, bbox_inches="tight")
+    buf.seek(0)
+    b64 = base64.b64encode(buf.read()).decode("utf-8")
+    buf.close()
+    return b64
+
+
+def _plot_from_spec(spec: PlotSpec) -> str:
+    # Build figure
+    fig, ax = plt.subplots(figsize=(spec.width or 6.0, spec.height or 4.0))
+
+    # Normalize data
+    data = spec.data or {}
+    is_rows = isinstance(data, list)
+    is_arrays = isinstance(data, dict) and all(isinstance(v, list) for v in data.values())
+
+    def extract_series(xkey, ykey):
+        if is_rows:
+            xs = [row.get(xkey) for row in data]
+            ys = [row.get(ykey) for row in data]
+        elif is_arrays:
+            xs = data.get(xkey) if xkey else range(len(data.get(ykey, [])))
+            ys = data.get(ykey, [])
+        else:
+            raise ValueError("Unsupported data format. Provide list[dict] or dict of arrays.")
+        return xs, ys
+
+    # Handle y being single or multiple
+    y_keys = [spec.y] if isinstance(spec.y, (str, type(None))) else list(spec.y or [])
+    if not y_keys:  # auto-choose 'y' if present
+        y_keys = ["y"] if (is_arrays and "y" in data) else []
+        if not y_keys:
+            raise ValueError("Could not infer 'y' series; please set y.")
+
+    # Plot by chart_type
+    if spec.chart_type == "line":
+        for ykey in y_keys:
+            xs, ys = extract_series(spec.x, ykey)
+            ax.plot(xs, ys, alpha=spec.alpha, label=ykey if len(y_keys) > 1 else None)
+    elif spec.chart_type == "bar":
+        # Simple grouped bar if multiple y
+        import numpy as np
+        xs, _ = extract_series(spec.x, y_keys[0])
+        x_index = np.arange(len(xs))
+        n = len(y_keys)
+        width = 0.8 / n
+        for i, ykey in enumerate(y_keys):
+            _, ys = extract_series(spec.x, ykey)
+            ax.bar(x_index + i * width, ys, width=width, alpha=spec.alpha, label=ykey)
+        ax.set_xticks(x_index + width * (n - 1) / 2)
+        ax.set_xticklabels(xs, rotation=0)
+    elif spec.chart_type == "scatter":
+        for ykey in y_keys:
+            xs, ys = extract_series(spec.x, ykey)
+            ax.scatter(xs, ys, alpha=spec.alpha, label=ykey if len(y_keys) > 1 else None)
+    elif spec.chart_type == "hist":
+        # Expect a single series in y
+        xs, ys = extract_series(spec.x, y_keys[0])
+        values = ys if ys else xs
+        ax.hist(values, alpha=spec.alpha)
+    elif spec.chart_type == "area":
+        for ykey in y_keys:
+            xs, ys = extract_series(spec.x, ykey)
+            ax.fill_between(xs, ys, alpha=spec.alpha, label=ykey if len(y_keys) > 1 else None)
+    else:
+        raise ValueError("Unsupported chart_type. Use line|bar|scatter|hist|area.")
+
+    # Labels & cosmetics
+    if spec.title:
+        ax.set_title(spec.title)
+    if spec.xlabel:
+        ax.set_xlabel(spec.xlabel)
+    if spec.ylabel:
+        ax.set_ylabel(spec.ylabel)
+    if spec.grid:
+        ax.grid(True, linestyle="--", linewidth=0.5, alpha=0.5)
+    if spec.legend and len(y_keys) > 1:
+        ax.legend()
+
+    # Return base64
+    b64 = _png_base64_from_fig(fig)
+    plt.close(fig)
+    return b64
+
+
+def _plot_from_code(code: str) -> str:
+    """
+    Execute minimal matplotlib code that must define 'fig' and 'ax'.
+    VERY LIMITED namespace to reduce risk.
+    """
+    import numpy as np
+
+    allowed_globals = {
+        "__builtins__": {
+            "len": len, "range": range, "min": min, "max": max, "sum": sum, "abs": abs
+        },
+        "np": np,
+        "plt": plt,
+    }
+    local_vars = {}
+
+    # Simple guardrails
+    forbidden = ["import os", "import sys", "open(", "subprocess", "socket", "eval(", "exec("]
+    if any(tok in code for tok in forbidden):
+        raise ValueError("Disallowed token in python_code.")
+
+    exec(code, allowed_globals, local_vars)  # noqa: S102 (intentional, guarded)
+    fig = local_vars.get("fig")
+    ax = local_vars.get("ax")
+    if fig is None or ax is None:
+        raise ValueError("Your python_code must create variables 'fig' and 'ax'.")
+    b64 = _png_base64_from_fig(fig)
+    plt.close(fig)
+    return b64
+
+
+class PlotReturn(BaseModel):
+    mime_type: Literal["image/png"] = "image/png"
+    data_base64: str
+    alt_text: Optional[str] = None
+    debug: Optional[str] = None
+
+
+@tool(args_schema=PlotSpec)
+def generate_plot(**kwargs) -> str:
+    """
+    Generate a plot image (PNG base64). Returns a JSON string with keys:
+      - mime_type: 'image/png'
+      - data_base64: <base64 string>
+      - alt_text: optional
+    """
+    spec = PlotSpec(**kwargs)
+    try:
+        if spec.python_code:
+            b64 = _plot_from_code(spec.python_code)
+            alt = spec.title or "Custom matplotlib figure"
+        else:
+            b64 = _plot_from_spec(spec)
+            alt = spec.title or (
+                f"{spec.chart_type} plot" if spec.chart_type else "Plot"
+            )
+        result = PlotReturn(data_base64=b64, alt_text=alt)
+        # Return a stringified JSON so the LLM can pass it through easily
+        return f"""data:{result.mime_type};base64,{result.data_base64}"""
+    except Exception as e:
+        # Return an error payload the orchestrator can handle
+        err = PlotReturn(
+            data_base64="",
+            alt_text="Plot generation failed.",
+            debug=str(e),
+        )
+        return err.model_dump_json()

fairo-25.9.2/fairo/core/tools/suggestion.py

@@ -0,0 +1,43 @@
+import json
+from typing import List, Literal, Optional
+from pydantic import BaseModel, Field
+from langchain_core.tools import tool
+
+class ChatSuggestion(BaseModel):
+    action: Optional[Literal["enable_chat"]] = Field(default=None, description="Custom actions available to be dispatched by the chat interface")
+    prompt: str = Field(..., description="Suggestion text to show in UI")
+    model_config = {
+        "extra": "ignore"
+    }
+
+class ChatSuggestions(BaseModel):
+    chat_enabled: Optional[bool] = Field(default=True, description="This will let user only answer using the suggestions provided")
+    suggestions: List[ChatSuggestion] = Field(..., description="List of suggestions that will be available for the user")
+
+@tool(args_schema=ChatSuggestions)
+def send_chat_suggestions(chat_enabled: Optional[bool] = True,
+    suggestions: List[ChatSuggestion] = None):
+    """
+        This tool can be used to provide user predefined prompts and help during the user experience
+        Example input:
+        {
+            "suggestions": [
+                {
+                    "action": null,
+                    "prompt": "Suggestion 1 Prompt"
+                },
+                {
+                    "action": null,
+                    "prompt": "Suggestion 2 Prompt"
+                },
+                {
+                    "action": "enable_chat",
+                    "prompt": "Other"
+                }
+            ],
+        } 
+    """
+    # No side-effects needed; return the same payload so it's accessible
+    if not suggestions:
+        return []
+    return {"chat_enabled": chat_enabled, "suggestions": [s.model_dump() for s in suggestions]}

fairo-25.9.2/fairo/core/utils.py

@@ -0,0 +1,28 @@
+def parse_chat_interface_output(agent_executor_result):
+    """
+        Parses agent executor result into chat interface response
+        return_intermediate_steps must be set as true on the AgentExecutor in order to properly parse plot and suggestions
+    """
+    messages = [{"role": "assistant", "content": [
+                {
+                    "type": "text",
+                    "text": agent_executor_result["output"]
+                }
+            ]}]
+    suggestions = []
+    intermediate_steps = agent_executor_result.get('intermediate_steps', [])
+    for step, output  in intermediate_steps:
+        if step.tool == "generate_plot":
+            messages.append({"role": "assistant", "content": [
+                {
+                    "type": "image",
+                    "image": output
+                }
+            ]})
+        if step.tool == "send_chat_suggestions":
+            suggestions = output
+            
+    return {
+        "messages": messages,
+        "suggestions": suggestions
+    }

{fairo-25.8.2 → fairo-25.9.2}/fairo/core/workflow/dependency.py

@@ -1,155 +1,16 @@
 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.settings import get_mlflow_gateway_embeddings_route, get_mlflow_gateway_uri, get_fairo_api_key, get_fairo_api_secret, get_fairo_base_url
 from fairo.core.client.client import BaseClient
-AWS_AI_EMBEDDING_MODEL = 'cohere.embed-english-v3'
 import requests
-import uuid
+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
-        )
-
 class FairoVectorStore(BaseVectorStore):
     """
     A vector store implementation using the Fairo API
@@ -182,14 +43,18 @@ class FairoVectorStore(BaseVectorStore):
         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")
+        self.username = username or get_fairo_api_key()
+        self.password = password or get_fairo_api_secret()
+        self.api_url = api_url or get_fairo_base_url()
         self.fairo_auth_token = os.environ.get("FAIRO_AUTH_TOKEN")
-
+        # Setup credentials
         if not self.fairo_auth_token and (not self.username or not self.password):
             raise ValueError("Fairo API credentials must be provided either as FAIRO_AUTH_TOKEN or as parameters or in the FAIRO_USERNAME and FAIRO_PASSWORD environment variables")
 
+        if(self.username and self.password):
+            os.environ["MLFLOW_TRACKING_USERNAME"] = self.username
+            os.environ["MLFLOW_TRACKING_PASSWORD"] = self.password
+            
         # Initialize API client
         self.client = BaseClient(
             base_url=self.api_url.rstrip('/'),
@@ -429,7 +294,7 @@ class FairoVectorStore(BaseVectorStore):
                      collection_name: str,
                      username: str = None,
                      password: str = None,
-                     api_url: str = "https://api.fairo.ai",
+                     api_url: str = get_fairo_base_url(),
                      embedding_model_id: str = AWS_AI_EMBEDDING_MODEL,
                      region_name: str = None):
         """

{fairo-25.8.2 → fairo-25.9.2}/fairo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairo
-Version: 25.8.2
+Version: 25.9.2
 Summary: SDK for interfacing with Fairo SaaS platform.
 Author-email: "Fairo Systems, Inc." <support@fairo.ai>
 License: Apache-2.0
@@ -11,14 +11,12 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
-Requires-Dist: mlflow<=3.2.0,>=3.1.0
+Requires-Dist: mlflow<=3.1.1,>=3.1.0
 Requires-Dist: langchain<0.4.0,>=0.3.20
 Requires-Dist: langchain-aws<0.3.0,>=0.2.18
 Requires-Dist: langchain-community<0.4.0,>=0.3.20
 Requires-Dist: langchain-core<0.4.0,>=0.3.49
 Requires-Dist: langchain-text-splitters<0.4.0,>=0.3.7
-Requires-Dist: psycopg2-binary<3.0.0,>=2.9.0
-Requires-Dist: langchain-postgres<0.1.0,>=0.0.14
 Requires-Dist: setuptools>=79.0.0
 Requires-Dist: pandas<3.0.0,>=2.0.0
 

{fairo-25.8.2 → fairo-25.9.2}/fairo.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ fairo.egg-info/requires.txt
 fairo.egg-info/top_level.txt
 fairo/core/__init__.py
 fairo/core/exceptions.py
+fairo/core/utils.py
 fairo/core/agent/__init__.py
 fairo/core/agent/base_agent.py
 fairo/core/agent/code_analysis_agent.py
@@ -34,6 +35,9 @@ fairo/core/models/custom_field_value.py
 fairo/core/models/resources.py
 fairo/core/runnable/__init__.py
 fairo/core/runnable/runnable.py
+fairo/core/tools/__init__.py
+fairo/core/tools/plot.py
+fairo/core/tools/suggestion.py
 fairo/core/workflow/__init__.py
 fairo/core/workflow/base_workflow.py
 fairo/core/workflow/dependency.py

{fairo-25.8.2 → fairo-25.9.2}/fairo.egg-info/requires.txt

@@ -1,10 +1,8 @@
-mlflow<=3.2.0,>=3.1.0
+mlflow<=3.1.1,>=3.1.0
 langchain<0.4.0,>=0.3.20
 langchain-aws<0.3.0,>=0.2.18
 langchain-community<0.4.0,>=0.3.20
 langchain-core<0.4.0,>=0.3.49
 langchain-text-splitters<0.4.0,>=0.3.7
-psycopg2-binary<3.0.0,>=2.9.0
-langchain-postgres<0.1.0,>=0.0.14
 setuptools>=79.0.0
 pandas<3.0.0,>=2.0.0

{fairo-25.8.2 → fairo-25.9.2}/pyproject.toml

@@ -20,14 +20,12 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "mlflow>=3.1.0,<=3.2.0",
+    "mlflow>=3.1.0,<=3.1.1",
     "langchain>=0.3.20,<0.4.0",
     "langchain-aws>=0.2.18,<0.3.0",
     "langchain-community>=0.3.20,<0.4.0",
     "langchain-core>=0.3.49,<0.4.0",
     "langchain-text-splitters>=0.3.7,<0.4.0",
-    "psycopg2-binary>=2.9.0,<3.0.0",
-    "langchain-postgres>=0.0.14,<0.1.0",
     "setuptools>=79.0.0",
     "pandas>=2.0.0,<3.0.0"
 ]

fairo-25.8.2/fairo/__init__.py

@@ -1 +0,0 @@
-__version__ = "25.8.2"