langflow-base-nightly 0.5.1.dev3__py3-none-any.whl → 0.5.1.dev5__py3-none-any.whl

langflow/components/langchain_utilities/sql_generator.py

@@ -1,78 +0,0 @@
-from typing import TYPE_CHECKING
-
-from langchain.chains import create_sql_query_chain
-from langchain_core.prompts import PromptTemplate
-
-from langflow.base.chains.model import LCChainComponent
-from langflow.inputs.inputs import HandleInput, IntInput, MultilineInput
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-if TYPE_CHECKING:
-    from langchain_core.runnables import Runnable
-
-
-class SQLGeneratorComponent(LCChainComponent):
-    display_name = "Natural Language to SQL"
-    description = "Generate SQL from natural language."
-    name = "SQLGenerator"
-    legacy: bool = True
-    icon = "LangChain"
-
-    inputs = [
-        MultilineInput(
-            name="input_value",
-            display_name="Input",
-            info="The input value to pass to the chain.",
-            required=True,
-        ),
-        HandleInput(
-            name="llm",
-            display_name="Language Model",
-            input_types=["LanguageModel"],
-            required=True,
-        ),
-        HandleInput(
-            name="db",
-            display_name="SQLDatabase",
-            input_types=["SQLDatabase"],
-            required=True,
-        ),
-        IntInput(
-            name="top_k",
-            display_name="Top K",
-            info="The number of results per select statement to return.",
-            value=5,
-        ),
-        MultilineInput(
-            name="prompt",
-            display_name="Prompt",
-            info="The prompt must contain `{question}`.",
-        ),
-    ]
-
-    outputs = [Output(display_name="Message", name="text", method="invoke_chain")]
-
-    def invoke_chain(self) -> Message:
-        prompt_template = PromptTemplate.from_template(template=self.prompt) if self.prompt else None
-
-        if self.top_k < 1:
-            msg = "Top K must be greater than 0."
-            raise ValueError(msg)
-
-        if not prompt_template:
-            sql_query_chain = create_sql_query_chain(llm=self.llm, db=self.db, k=self.top_k)
-        else:
-            # Check if {question} is in the prompt
-            if "{question}" not in prompt_template.template or "question" not in prompt_template.input_variables:
-                msg = "Prompt must contain `{question}` to be used with Natural Language to SQL."
-                raise ValueError(msg)
-            sql_query_chain = create_sql_query_chain(llm=self.llm, db=self.db, prompt=prompt_template, k=self.top_k)
-        query_writer: Runnable = sql_query_chain | {"query": lambda x: x.replace("SQLQuery:", "").strip()}
-        response = query_writer.invoke(
-            {"question": self.input_value},
-            config={"callbacks": self.get_langchain_callbacks()},
-        )
-        query = response.get("query")
-        self.status = query
-        return query

langflow/components/langchain_utilities/tool_calling.py

@@ -1,59 +0,0 @@
-from langchain.agents import create_tool_calling_agent
-from langchain_core.prompts import ChatPromptTemplate
-
-from langflow.base.agents.agent import LCToolsAgentComponent
-from langflow.inputs.inputs import (
-    DataInput,
-    HandleInput,
-    MessageTextInput,
-)
-from langflow.schema.data import Data
-
-
-class ToolCallingAgentComponent(LCToolsAgentComponent):
-    display_name: str = "Tool Calling Agent"
-    description: str = "An agent designed to utilize various tools seamlessly within workflows."
-    icon = "LangChain"
-    name = "ToolCallingAgent"
-
-    inputs = [
-        *LCToolsAgentComponent._base_inputs,
-        HandleInput(
-            name="llm",
-            display_name="Language Model",
-            input_types=["LanguageModel"],
-            required=True,
-            info="Language model that the agent utilizes to perform tasks effectively.",
-        ),
-        MessageTextInput(
-            name="system_prompt",
-            display_name="System Prompt",
-            info="System prompt to guide the agent's behavior.",
-            value="You are a helpful assistant that can use tools to answer questions and perform tasks.",
-        ),
-        DataInput(
-            name="chat_history",
-            display_name="Chat Memory",
-            is_list=True,
-            advanced=True,
-            info="This input stores the chat history, allowing the agent to remember previous conversations.",
-        ),
-    ]
-
-    def get_chat_history_data(self) -> list[Data] | None:
-        return self.chat_history
-
-    def create_agent_runnable(self):
-        messages = [
-            ("system", "{system_prompt}"),
-            ("placeholder", "{chat_history}"),
-            ("human", "{input}"),
-            ("placeholder", "{agent_scratchpad}"),
-        ]
-        prompt = ChatPromptTemplate.from_messages(messages)
-        self.validate_tool_names()
-        try:
-            return create_tool_calling_agent(self.llm, self.tools or [], prompt)
-        except NotImplementedError as e:
-            message = f"{self.display_name} does not support tool calling. Please try using a compatible model."
-            raise NotImplementedError(message) from e

langflow/components/langchain_utilities/vector_store_info.py

@@ -1,49 +0,0 @@
-from langchain.agents.agent_toolkits.vectorstore.toolkit import VectorStoreInfo
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import HandleInput, MessageTextInput, MultilineInput
-from langflow.template.field.base import Output
-
-
-class VectorStoreInfoComponent(Component):
-    display_name = "VectorStoreInfo"
-    description = "Information about a VectorStore"
-    name = "VectorStoreInfo"
-    legacy: bool = True
-    icon = "LangChain"
-
-    inputs = [
-        MessageTextInput(
-            name="vectorstore_name",
-            display_name="Name",
-            info="Name of the VectorStore",
-            required=True,
-        ),
-        MultilineInput(
-            name="vectorstore_description",
-            display_name="Description",
-            info="Description of the VectorStore",
-            required=True,
-        ),
-        HandleInput(
-            name="input_vectorstore",
-            display_name="Vector Store",
-            input_types=["VectorStore"],
-            required=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Vector Store Info", name="info", method="build_info"),
-    ]
-
-    def build_info(self) -> VectorStoreInfo:
-        self.status = {
-            "name": self.vectorstore_name,
-            "description": self.vectorstore_description,
-        }
-        return VectorStoreInfo(
-            vectorstore=self.input_vectorstore,
-            description=self.vectorstore_description,
-            name=self.vectorstore_name,
-        )

langflow/components/langchain_utilities/vector_store_router.py

@@ -1,33 +0,0 @@
-from langchain.agents import AgentExecutor, create_vectorstore_router_agent
-from langchain.agents.agent_toolkits.vectorstore.toolkit import VectorStoreRouterToolkit
-
-from langflow.base.agents.agent import LCAgentComponent
-from langflow.inputs.inputs import HandleInput
-
-
-class VectorStoreRouterAgentComponent(LCAgentComponent):
-    display_name = "VectorStoreRouterAgent"
-    description = "Construct an agent from a Vector Store Router."
-    name = "VectorStoreRouterAgent"
-    legacy: bool = True
-
-    inputs = [
-        *LCAgentComponent._base_inputs,
-        HandleInput(
-            name="llm",
-            display_name="Language Model",
-            input_types=["LanguageModel"],
-            required=True,
-        ),
-        HandleInput(
-            name="vectorstores",
-            display_name="Vector Stores",
-            input_types=["VectorStoreInfo"],
-            is_list=True,
-            required=True,
-        ),
-    ]
-
-    def build_agent(self) -> AgentExecutor:
-        toolkit = VectorStoreRouterToolkit(vectorstores=self.vectorstores, llm=self.llm)
-        return create_vectorstore_router_agent(llm=self.llm, toolkit=toolkit, **self.get_agent_kwargs())

langflow/components/langchain_utilities/xml_agent.py

@@ -1,71 +0,0 @@
-from langchain.agents import create_xml_agent
-from langchain_core.prompts import ChatPromptTemplate, HumanMessagePromptTemplate, PromptTemplate
-
-from langflow.base.agents.agent import LCToolsAgentComponent
-from langflow.inputs.inputs import (
-    DataInput,
-    HandleInput,
-    MultilineInput,
-)
-from langflow.schema.data import Data
-
-
-class XMLAgentComponent(LCToolsAgentComponent):
-    display_name: str = "XML Agent"
-    description: str = "Agent that uses tools formatting instructions as xml to the Language Model."
-    icon = "LangChain"
-    beta = True
-    name = "XMLAgent"
-    inputs = [
-        *LCToolsAgentComponent._base_inputs,
-        HandleInput(name="llm", display_name="Language Model", input_types=["LanguageModel"], required=True),
-        DataInput(name="chat_history", display_name="Chat History", is_list=True, advanced=True),
-        MultilineInput(
-            name="system_prompt",
-            display_name="System Prompt",
-            info="System prompt for the agent.",
-            value="""You are a helpful assistant. Help the user answer any questions.
-
-You have access to the following tools:
-
-{tools}
-
-In order to use a tool, you can use <tool></tool> and <tool_input></tool_input> tags. You will then get back a response in the form <observation></observation>
-
-For example, if you have a tool called 'search' that could run a google search, in order to search for the weather in SF you would respond:
-
-<tool>search</tool><tool_input>weather in SF</tool_input>
-
-<observation>64 degrees</observation>
-
-When you are done, respond with a final answer between <final_answer></final_answer>. For example:
-
-<final_answer>The weather in SF is 64 degrees</final_answer>
-
-Begin!
-
-Question: {input}
-
-{agent_scratchpad}
-            """,  # noqa: E501
-        ),
-        MultilineInput(
-            name="user_prompt", display_name="Prompt", info="This prompt must contain 'input' key.", value="{input}"
-        ),
-    ]
-
-    def get_chat_history_data(self) -> list[Data] | None:
-        return self.chat_history
-
-    def create_agent_runnable(self):
-        if "input" not in self.user_prompt:
-            msg = "Prompt must contain 'input' key."
-            raise ValueError(msg)
-        messages = [
-            ("system", self.system_prompt),
-            ("placeholder", "{chat_history}"),
-            HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=["input"], template=self.user_prompt)),
-            ("ai", "{agent_scratchpad}"),
-        ]
-        prompt = ChatPromptTemplate.from_messages(messages)
-        return create_xml_agent(self.llm, self.tools, prompt)

langflow/components/langwatch/__init__.py

@@ -1,3 +0,0 @@
-from .langwatch import LangWatchComponent
-
-__all__ = ["LangWatchComponent"]

langflow/components/langwatch/langwatch.py

@@ -1,278 +0,0 @@
-import json
-import os
-from typing import Any
-
-import httpx
-
-from langflow.base.langwatch.utils import get_cached_evaluators
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import MultilineInput
-from langflow.io import (
-    BoolInput,
-    DropdownInput,
-    FloatInput,
-    IntInput,
-    MessageTextInput,
-    NestedDictInput,
-    Output,
-    SecretStrInput,
-)
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.schema.dotdict import dotdict
-
-
-class LangWatchComponent(Component):
-    display_name: str = "LangWatch Evaluator"
-    description: str = "Evaluates various aspects of language models using LangWatch's evaluation endpoints."
-    documentation: str = "https://docs.langwatch.ai/langevals/documentation/introduction"
-    icon: str = "Langwatch"
-    name: str = "LangWatchEvaluator"
-
-    inputs = [
-        DropdownInput(
-            name="evaluator_name",
-            display_name="Evaluator Name",
-            options=[],
-            required=True,
-            info="Select an evaluator.",
-            refresh_button=True,
-            real_time_refresh=True,
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="API Key",
-            required=True,
-            info="Enter your LangWatch API key.",
-        ),
-        MessageTextInput(
-            name="input",
-            display_name="Input",
-            required=False,
-            info="The input text for evaluation.",
-        ),
-        MessageTextInput(
-            name="output",
-            display_name="Output",
-            required=False,
-            info="The output text for evaluation.",
-        ),
-        MessageTextInput(
-            name="expected_output",
-            display_name="Expected Output",
-            required=False,
-            info="The expected output for evaluation.",
-        ),
-        MessageTextInput(
-            name="contexts",
-            display_name="Contexts",
-            required=False,
-            info="The contexts for evaluation (comma-separated).",
-        ),
-        IntInput(
-            name="timeout",
-            display_name="Timeout",
-            info="The maximum time (in seconds) allowed for the server to respond before timing out.",
-            value=30,
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(name="evaluation_result", display_name="Evaluation Result", method="evaluate"),
-    ]
-
-    def set_evaluators(self, endpoint: str):
-        url = f"{endpoint}/api/evaluations/list"
-        self.evaluators = get_cached_evaluators(url)
-        if not self.evaluators or len(self.evaluators) == 0:
-            self.status = f"No evaluators found from {endpoint}"
-            msg = f"No evaluators found from {endpoint}"
-            raise ValueError(msg)
-
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
-        try:
-            logger.info(f"Updating build config. Field name: {field_name}, Field value: {field_value}")
-
-            if field_name is None or field_name == "evaluator_name":
-                self.evaluators = self.get_evaluators(os.getenv("LANGWATCH_ENDPOINT", "https://app.langwatch.ai"))
-                build_config["evaluator_name"]["options"] = list(self.evaluators.keys())
-
-                # Set a default evaluator if none is selected
-                if not getattr(self, "current_evaluator", None) and self.evaluators:
-                    self.current_evaluator = next(iter(self.evaluators))
-                    build_config["evaluator_name"]["value"] = self.current_evaluator
-
-                # Define default keys that should always be present
-                default_keys = ["code", "_type", "evaluator_name", "api_key", "input", "output", "timeout"]
-
-                if field_value and field_value in self.evaluators and self.current_evaluator != field_value:
-                    self.current_evaluator = field_value
-                    evaluator = self.evaluators[field_value]
-
-                    # Clear previous dynamic inputs
-                    keys_to_remove = [key for key in build_config if key not in default_keys]
-                    for key in keys_to_remove:
-                        del build_config[key]
-
-                    # Clear component's dynamic attributes
-                    for attr in list(self.__dict__.keys()):
-                        if attr not in default_keys and attr not in {
-                            "evaluators",
-                            "dynamic_inputs",
-                            "_code",
-                            "current_evaluator",
-                        }:
-                            delattr(self, attr)
-
-                    # Add new dynamic inputs
-                    self.dynamic_inputs = self.get_dynamic_inputs(evaluator)
-                    for name, input_config in self.dynamic_inputs.items():
-                        build_config[name] = input_config.to_dict()
-
-                    # Update required fields
-                    required_fields = {"api_key", "evaluator_name"}.union(evaluator.get("requiredFields", []))
-                    for key in build_config:
-                        if isinstance(build_config[key], dict):
-                            build_config[key]["required"] = key in required_fields
-
-                # Validate presence of default keys
-                missing_keys = [key for key in default_keys if key not in build_config]
-                if missing_keys:
-                    logger.warning(f"Missing required keys in build_config: {missing_keys}")
-                    # Add missing keys with default values
-                    for key in missing_keys:
-                        build_config[key] = {"value": None, "type": "str"}
-
-            # Ensure the current_evaluator is always set in the build_config
-            build_config["evaluator_name"]["value"] = self.current_evaluator
-
-            logger.info(f"Current evaluator set to: {self.current_evaluator}")
-
-        except (KeyError, AttributeError, ValueError) as e:
-            self.status = f"Error updating component: {e!s}"
-        return build_config
-
-    def get_dynamic_inputs(self, evaluator: dict[str, Any]):
-        try:
-            dynamic_inputs = {}
-
-            input_fields = [
-                field
-                for field in evaluator.get("requiredFields", []) + evaluator.get("optionalFields", [])
-                if field not in {"input", "output"}
-            ]
-
-            for field in input_fields:
-                input_params = {
-                    "name": field,
-                    "display_name": field.replace("_", " ").title(),
-                    "required": field in evaluator.get("requiredFields", []),
-                }
-                if field == "contexts":
-                    dynamic_inputs[field] = MultilineInput(**input_params, multiline=True)
-                else:
-                    dynamic_inputs[field] = MessageTextInput(**input_params)
-
-            settings = evaluator.get("settings", {})
-            for setting_name, setting_config in settings.items():
-                schema = evaluator.get("settings_json_schema", {}).get("properties", {}).get(setting_name, {})
-
-                input_params = {
-                    "name": setting_name,
-                    "display_name": setting_name.replace("_", " ").title(),
-                    "info": setting_config.get("description", ""),
-                    "required": False,
-                }
-
-                if schema.get("type") == "object":
-                    input_type = NestedDictInput
-                    input_params["value"] = schema.get("default", setting_config.get("default", {}))
-                elif schema.get("type") == "boolean":
-                    input_type = BoolInput
-                    input_params["value"] = schema.get("default", setting_config.get("default", False))
-                elif schema.get("type") == "number":
-                    is_float = isinstance(schema.get("default", setting_config.get("default")), float)
-                    input_type = FloatInput if is_float else IntInput
-                    input_params["value"] = schema.get("default", setting_config.get("default", 0))
-                elif "enum" in schema:
-                    input_type = DropdownInput
-                    input_params["options"] = schema["enum"]
-                    input_params["value"] = schema.get("default", setting_config.get("default"))
-                else:
-                    input_type = MessageTextInput
-                    default_value = schema.get("default", setting_config.get("default"))
-                    input_params["value"] = str(default_value) if default_value is not None else ""
-
-                dynamic_inputs[setting_name] = input_type(**input_params)
-
-        except (KeyError, AttributeError, ValueError, TypeError) as e:
-            self.status = f"Error creating dynamic inputs: {e!s}"
-            return {}
-        return dynamic_inputs
-
-    async def evaluate(self) -> Data:
-        if not self.api_key:
-            return Data(data={"error": "API key is required"})
-
-        self.set_evaluators(os.getenv("LANGWATCH_ENDPOINT", "https://app.langwatch.ai"))
-        self.dynamic_inputs = {}
-        if getattr(self, "current_evaluator", None) is None and self.evaluators:
-            self.current_evaluator = next(iter(self.evaluators))
-
-        # Prioritize evaluator_name if it exists
-        evaluator_name = getattr(self, "evaluator_name", None) or self.current_evaluator
-
-        if not evaluator_name:
-            if self.evaluators:
-                evaluator_name = next(iter(self.evaluators))
-                await logger.ainfo(f"No evaluator was selected. Using default: {evaluator_name}")
-            else:
-                return Data(
-                    data={"error": "No evaluator selected and no evaluators available. Please choose an evaluator."}
-                )
-
-        try:
-            evaluator = self.evaluators.get(evaluator_name)
-            if not evaluator:
-                return Data(data={"error": f"Selected evaluator '{evaluator_name}' not found."})
-
-            await logger.ainfo(f"Evaluating with evaluator: {evaluator_name}")
-
-            endpoint = f"/api/evaluations/{evaluator_name}/evaluate"
-            url = f"{os.getenv('LANGWATCH_ENDPOINT', 'https://app.langwatch.ai')}{endpoint}"
-
-            headers = {"Content-Type": "application/json", "X-Auth-Token": self.api_key}
-
-            payload = {
-                "data": {
-                    "input": self.input,
-                    "output": self.output,
-                    "expected_output": self.expected_output,
-                    "contexts": self.contexts.split(",") if self.contexts else [],
-                },
-                "settings": {},
-            }
-
-            if self._tracing_service:
-                tracer = self._tracing_service.get_tracer("langwatch")
-                if tracer is not None and hasattr(tracer, "trace_id"):
-                    payload["settings"]["trace_id"] = str(tracer.trace_id)
-
-            for setting_name in self.dynamic_inputs:
-                payload["settings"][setting_name] = getattr(self, setting_name, None)
-
-            async with httpx.AsyncClient(timeout=self.timeout) as client:
-                response = await client.post(url, json=payload, headers=headers)
-
-            response.raise_for_status()
-            result = response.json()
-
-            formatted_result = json.dumps(result, indent=2)
-            self.status = f"Evaluation completed successfully. Result:\n{formatted_result}"
-            return Data(data=result)
-
-        except (httpx.RequestError, KeyError, AttributeError, ValueError) as e:
-            error_message = f"Evaluation error: {e!s}"
-            self.status = error_message
-            return Data(data={"error": error_message})

langflow/components/lmstudio/__init__.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from langflow.components.lmstudio.lmstudioembeddings import LMStudioEmbeddingsComponent
-    from langflow.components.lmstudio.lmstudiomodel import LMStudioModelComponent
-
-_dynamic_imports = {
-    "LMStudioEmbeddingsComponent": "lmstudioembeddings",
-    "LMStudioModelComponent": "lmstudiomodel",
-}
-
-__all__ = ["LMStudioEmbeddingsComponent", "LMStudioModelComponent"]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import lmstudio 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__)