lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/vertexai/__init__.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .vertexai import ChatVertexAIComponent
+    from .vertexai_embeddings import VertexAIEmbeddingsComponent
+
+_dynamic_imports = {
+    "ChatVertexAIComponent": "vertexai",
+    "VertexAIEmbeddingsComponent": "vertexai_embeddings",
+}
+
+__all__ = [
+    "ChatVertexAIComponent",
+    "VertexAIEmbeddingsComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import vertexai components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/vertexai/vertexai.py

@@ -0,0 +1,71 @@
+from typing import cast
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.inputs.inputs import MessageTextInput
+from lfx.io import BoolInput, FileInput, FloatInput, IntInput, StrInput
+
+
+class ChatVertexAIComponent(LCModelComponent):
+    display_name = "Vertex AI"
+    description = "Generate text using Vertex AI LLMs."
+    icon = "VertexAI"
+    name = "VertexAiModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        FileInput(
+            name="credentials",
+            display_name="Credentials",
+            info="JSON credentials file. Leave empty to fallback to environment variables",
+            file_types=["json"],
+        ),
+        MessageTextInput(name="model_name", display_name="Model Name", value="gemini-1.5-pro"),
+        StrInput(name="project", display_name="Project", info="The project ID.", advanced=True),
+        StrInput(name="location", display_name="Location", value="us-central1", advanced=True),
+        IntInput(name="max_output_tokens", display_name="Max Output Tokens", advanced=True),
+        IntInput(name="max_retries", display_name="Max Retries", value=1, advanced=True),
+        FloatInput(name="temperature", value=0.0, display_name="Temperature"),
+        IntInput(name="top_k", display_name="Top K", advanced=True),
+        FloatInput(name="top_p", display_name="Top P", value=0.95, advanced=True),
+        BoolInput(name="verbose", display_name="Verbose", value=False, advanced=True),
+    ]
+
+    def build_model(self) -> LanguageModel:
+        try:
+            from langchain_google_vertexai import ChatVertexAI
+        except ImportError as e:
+            msg = "Please install the langchain-google-vertexai package to use the VertexAIEmbeddings component."
+            raise ImportError(msg) from e
+        location = self.location or None
+        if self.credentials:
+            from google.cloud import aiplatform
+            from google.oauth2 import service_account
+
+            credentials = service_account.Credentials.from_service_account_file(self.credentials)
+            project = self.project or credentials.project_id
+            # ChatVertexAI sometimes skip manual credentials initialization
+            aiplatform.init(
+                project=project,
+                location=location,
+                credentials=credentials,
+            )
+        else:
+            project = self.project or None
+            credentials = None
+
+        return cast(
+            "LanguageModel",
+            ChatVertexAI(
+                credentials=credentials,
+                location=location,
+                project=project,
+                max_output_tokens=self.max_output_tokens or None,
+                max_retries=self.max_retries,
+                model_name=self.model_name,
+                temperature=self.temperature,
+                top_k=self.top_k or None,
+                top_p=self.top_p,
+                verbose=self.verbose,
+            ),
+        )

lfx/components/vertexai/vertexai_embeddings.py

@@ -0,0 +1,67 @@
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import Embeddings
+from lfx.io import BoolInput, FileInput, FloatInput, IntInput, MessageTextInput, Output
+
+
+class VertexAIEmbeddingsComponent(LCModelComponent):
+    display_name = "Vertex AI Embeddings"
+    description = "Generate embeddings using Google Cloud Vertex AI models."
+    icon = "VertexAI"
+    name = "VertexAIEmbeddings"
+
+    inputs = [
+        FileInput(
+            name="credentials",
+            display_name="Credentials",
+            info="JSON credentials file. Leave empty to fallback to environment variables",
+            value="",
+            file_types=["json"],
+            required=True,
+        ),
+        MessageTextInput(name="location", display_name="Location", value="us-central1", advanced=True),
+        MessageTextInput(name="project", display_name="Project", info="The project ID.", advanced=True),
+        IntInput(name="max_output_tokens", display_name="Max Output Tokens", advanced=True),
+        IntInput(name="max_retries", display_name="Max Retries", value=1, advanced=True),
+        MessageTextInput(name="model_name", display_name="Model Name", value="textembedding-gecko", required=True),
+        IntInput(name="n", display_name="N", value=1, advanced=True),
+        IntInput(name="request_parallelism", value=5, display_name="Request Parallelism", advanced=True),
+        MessageTextInput(name="stop_sequences", display_name="Stop", advanced=True, is_list=True),
+        BoolInput(name="streaming", display_name="Streaming", value=False, advanced=True),
+        FloatInput(name="temperature", value=0.0, display_name="Temperature"),
+        IntInput(name="top_k", display_name="Top K", advanced=True),
+        FloatInput(name="top_p", display_name="Top P", value=0.95, advanced=True),
+    ]
+
+    outputs = [
+        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        try:
+            from langchain_google_vertexai import VertexAIEmbeddings
+        except ImportError as e:
+            msg = "Please install the langchain-google-vertexai package to use the VertexAIEmbeddings component."
+            raise ImportError(msg) from e
+
+        from google.oauth2 import service_account
+
+        if self.credentials:
+            gcloud_credentials = service_account.Credentials.from_service_account_file(self.credentials)
+        else:
+            # will fallback to environment variable or inferred from gcloud CLI
+            gcloud_credentials = None
+        return VertexAIEmbeddings(
+            credentials=gcloud_credentials,
+            location=self.location,
+            max_output_tokens=self.max_output_tokens or None,
+            max_retries=self.max_retries,
+            model_name=self.model_name,
+            n=self.n,
+            project=self.project,
+            request_parallelism=self.request_parallelism,
+            stop=self.stop_sequences or None,
+            streaming=self.streaming,
+            temperature=self.temperature,
+            top_k=self.top_k or None,
+            top_p=self.top_p,
+        )

lfx/components/weaviate/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .weaviate import WeaviateVectorStoreComponent
+
+_dynamic_imports = {
+    "WeaviateVectorStoreComponent": "weaviate",
+}
+
+__all__ = [
+    "WeaviateVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Weaviate components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/weaviate/weaviate.py

@@ -0,0 +1,89 @@
+import weaviate
+from langchain_community.vectorstores import Weaviate
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import BoolInput, HandleInput, IntInput, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class WeaviateVectorStoreComponent(LCVectorStoreComponent):
+    display_name = "Weaviate"
+    description = "Weaviate Vector Store with search capabilities"
+    name = "Weaviate"
+    icon = "Weaviate"
+
+    inputs = [
+        StrInput(name="url", display_name="Weaviate URL", value="http://localhost:8080", required=True),
+        SecretStrInput(name="api_key", display_name="API Key", required=False),
+        StrInput(
+            name="index_name",
+            display_name="Index Name",
+            required=True,
+            info="Requires capitalized index name.",
+        ),
+        StrInput(name="text_key", display_name="Text Key", value="text", advanced=True),
+        *LCVectorStoreComponent.inputs,
+        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return.",
+            value=4,
+            advanced=True,
+        ),
+        BoolInput(name="search_by_text", display_name="Search By Text", advanced=True),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> Weaviate:
+        if self.api_key:
+            auth_config = weaviate.AuthApiKey(api_key=self.api_key)
+            client = weaviate.Client(url=self.url, auth_client_secret=auth_config)
+        else:
+            client = weaviate.Client(url=self.url)
+
+        if self.index_name != self.index_name.capitalize():
+            msg = f"Weaviate requires the index name to be capitalized. Use: {self.index_name.capitalize()}"
+            raise ValueError(msg)
+
+        # Convert DataFrame to Data if needed using parent's method
+        self.ingest_data = self._prepare_ingest_data()
+
+        documents = []
+        for _input in self.ingest_data or []:
+            if isinstance(_input, Data):
+                documents.append(_input.to_lc_document())
+            else:
+                documents.append(_input)
+
+        if documents and self.embedding:
+            return Weaviate.from_documents(
+                client=client,
+                index_name=self.index_name,
+                documents=documents,
+                embedding=self.embedding,
+                by_text=self.search_by_text,
+            )
+
+        return Weaviate(
+            client=client,
+            index_name=self.index_name,
+            text_key=self.text_key,
+            embedding=self.embedding,
+            by_text=self.search_by_text,
+        )
+
+    def search_documents(self) -> list[Data]:
+        vector_store = self.build_vector_store()
+
+        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
+            docs = vector_store.similarity_search(
+                query=self.search_query,
+                k=self.number_of_results,
+            )
+
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []

lfx/components/wikipedia/__init__.py

@@ -0,0 +1,4 @@
+from .wikidata import WikidataComponent
+from .wikipedia import WikipediaComponent
+
+__all__ = ["WikidataComponent", "WikipediaComponent"]

lfx/components/wikipedia/wikidata.py

@@ -0,0 +1,86 @@
+import httpx
+from httpx import HTTPError
+from langchain_core.tools import ToolException
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import MultilineInput
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.template.field.base import Output
+
+
+class WikidataComponent(Component):
+    display_name = "Wikidata"
+    description = "Performs a search using the Wikidata API."
+    icon = "Wikipedia"
+
+    inputs = [
+        MultilineInput(
+            name="query",
+            display_name="Query",
+            info="The text query for similarity search on Wikidata.",
+            required=True,
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
+    ]
+
+    def run_model(self) -> DataFrame:
+        return self.fetch_content_dataframe()
+
+    def fetch_content(self) -> list[Data]:
+        try:
+            # Define request parameters for Wikidata API
+            params = {
+                "action": "wbsearchentities",
+                "format": "json",
+                "search": self.query,
+                "language": "en",
+            }
+
+            # Send request to Wikidata API
+            wikidata_api_url = "https://www.wikidata.org/w/api.php"
+            response = httpx.get(wikidata_api_url, params=params)
+            response.raise_for_status()
+            response_json = response.json()
+
+            # Extract search results
+            results = response_json.get("search", [])
+
+            if not results:
+                return [Data(data={"error": "No search results found for the given query."})]
+
+            # Transform the API response into Data objects
+            data = [
+                Data(
+                    text=f"{result['label']}: {result.get('description', '')}",
+                    data={
+                        "label": result["label"],
+                        "id": result.get("id"),
+                        "url": result.get("url"),
+                        "description": result.get("description", ""),
+                        "concepturi": result.get("concepturi"),
+                    },
+                )
+                for result in results
+            ]
+
+            self.status = data
+        except HTTPError as e:
+            error_message = f"HTTP Error in Wikidata Search API: {e!s}"
+            raise ToolException(error_message) from None
+        except KeyError as e:
+            error_message = f"Data parsing error in Wikidata API response: {e!s}"
+            raise ToolException(error_message) from None
+        except ValueError as e:
+            error_message = f"Value error in Wikidata API: {e!s}"
+            raise ToolException(error_message) from None
+        else:
+            return data
+
+    def fetch_content_dataframe(self) -> DataFrame:
+        data = self.fetch_content()
+        return DataFrame(data)

lfx/components/wikipedia/wikipedia.py

@@ -0,0 +1,53 @@
+from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import BoolInput, IntInput, MessageTextInput, MultilineInput
+from lfx.io import Output
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+
+
+class WikipediaComponent(Component):
+    display_name = "Wikipedia"
+    description = "Call Wikipedia API."
+    icon = "Wikipedia"
+
+    inputs = [
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+            tool_mode=True,
+        ),
+        MessageTextInput(name="lang", display_name="Language", value="en"),
+        IntInput(name="k", display_name="Number of results", value=4, required=True),
+        BoolInput(name="load_all_available_meta", display_name="Load all available meta", value=False, advanced=True),
+        IntInput(
+            name="doc_content_chars_max", display_name="Document content characters max", value=4000, advanced=True
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
+    ]
+
+    def run_model(self) -> DataFrame:
+        return self.fetch_content_dataframe()
+
+    def _build_wrapper(self) -> WikipediaAPIWrapper:
+        return WikipediaAPIWrapper(
+            top_k_results=self.k,
+            lang=self.lang,
+            load_all_available_meta=self.load_all_available_meta,
+            doc_content_chars_max=self.doc_content_chars_max,
+        )
+
+    def fetch_content(self) -> list[Data]:
+        wrapper = self._build_wrapper()
+        docs = wrapper.load(self.input_value)
+        data = [Data.from_document(doc) for doc in docs]
+        self.status = data
+        return data
+
+    def fetch_content_dataframe(self) -> DataFrame:
+        data = self.fetch_content()
+        return DataFrame(data)

lfx/components/wolframalpha/__init__.py

@@ -0,0 +1,3 @@
+from .wolfram_alpha_api import WolframAlphaAPIComponent
+
+__all__ = ["WolframAlphaAPIComponent"]

lfx/components/wolframalpha/wolfram_alpha_api.py

@@ -0,0 +1,54 @@
+from langchain_community.utilities.wolfram_alpha import WolframAlphaAPIWrapper
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import MultilineInput, SecretStrInput
+from lfx.io import Output
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+
+
+class WolframAlphaAPIComponent(LCToolComponent):
+    display_name = "WolframAlpha API"
+    description = """Enables queries to WolframAlpha for computational data, facts, and calculations across various \
+topics, delivering structured responses."""
+    name = "WolframAlphaAPI"
+
+    outputs = [
+        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
+    ]
+
+    inputs = [
+        MultilineInput(
+            name="input_value", display_name="Input Query", info="Example query: 'What is the population of France?'"
+        ),
+        SecretStrInput(name="app_id", display_name="App ID", required=True),
+    ]
+
+    icon = "WolframAlphaAPI"
+
+    def run_model(self) -> DataFrame:
+        return self.fetch_content_dataframe()
+
+    def build_tool(self) -> Tool:
+        wrapper = self._build_wrapper()
+        return Tool(name="wolfram_alpha_api", description="Answers mathematical questions.", func=wrapper.run)
+
+    def _build_wrapper(self) -> WolframAlphaAPIWrapper:
+        return WolframAlphaAPIWrapper(wolfram_alpha_appid=self.app_id)
+
+    def fetch_content(self) -> list[Data]:
+        wrapper = self._build_wrapper()
+        result_str = wrapper.run(self.input_value)
+        data = [Data(text=result_str)]
+        self.status = data
+        return data
+
+    def fetch_content_dataframe(self) -> DataFrame:
+        """Convert the WolframAlpha results to a DataFrame.
+
+        Returns:
+            DataFrame: A DataFrame containing the query results.
+        """
+        data = self.fetch_content()
+        return DataFrame(data)

lfx/components/xai/__init__.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.xai.xai import XAIModelComponent
+
+_dynamic_imports = {
+    "XAIModelComponent": "xai",
+}
+
+__all__ = ["XAIModelComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import xai components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)