composio-langgraph 0.3.28__py3-none-any.whl → 0.10.5__py3-none-any.whl

composio_langgraph/__init__.py

@@ -1,13 +1,3 @@
-from composio import Action, App, Tag, Trigger, WorkspaceType
+from .provider import LanggraphProvider
 
-from .toolset import ComposioToolSet
-
-
-__all__ = (
-    "Action",
-    "App",
-    "Tag",
-    "Trigger",
-    "WorkspaceType",
-    "ComposioToolSet",
-)
+__all__ = ("LanggraphProvider",)

composio_langgraph/provider.py

@@ -0,0 +1,93 @@
+"""ComposioLangChain class definition"""
+
+import types
+import typing as t
+from inspect import Signature
+
+import pydantic
+from langchain_core.tools import StructuredTool as BaseStructuredTool
+
+from composio.core.provider import AgenticProvider, AgenticProviderExecuteFn
+from composio.types import Tool
+from composio.utils.pydantic import parse_pydantic_error
+from composio.utils.shared import (
+    get_signature_format_from_schema_params,
+    json_schema_to_model,
+)
+
+
+class StructuredTool(BaseStructuredTool):  # type: ignore[misc]
+    def run(self, *args, **kwargs):
+        try:
+            return super().run(*args, **kwargs)
+        except pydantic.ValidationError as e:
+            return {"successful": False, "error": parse_pydantic_error(e), "data": None}
+
+
+class LanggraphProvider(
+    AgenticProvider[StructuredTool, t.List[StructuredTool]],
+    name="langgraph",
+):
+    """
+    Composio toolset for Langchain framework.
+    """
+
+    def _wrap_action(
+        self,
+        tool: str,
+        description: str,
+        schema_params: t.Dict,
+        execute_tool: AgenticProviderExecuteFn,
+    ):
+        def function(**kwargs: t.Any) -> t.Dict:
+            """Wrapper function for composio action."""
+            return execute_tool(tool, kwargs)
+
+        action_func = types.FunctionType(
+            function.__code__,
+            globals=globals(),
+            name=tool,
+            closure=function.__closure__,
+        )
+        action_func.__signature__ = Signature(  # type: ignore
+            parameters=get_signature_format_from_schema_params(
+                schema_params=schema_params
+            )
+        )
+        action_func.__doc__ = description
+        return action_func
+
+    def wrap_tool(
+        self, tool: Tool, execute_tool: AgenticProviderExecuteFn
+    ) -> StructuredTool:
+        """Wraps composio tool as Langchain StructuredTool object."""
+        return t.cast(
+            StructuredTool,
+            StructuredTool.from_function(
+                name=tool.slug,
+                description=tool.description,
+                args_schema=json_schema_to_model(
+                    json_schema=tool.input_parameters,
+                    skip_default=self.skip_default,
+                ),
+                return_schema=True,
+                func=self._wrap_action(
+                    tool=tool.slug,
+                    description=tool.description,
+                    schema_params=tool.input_parameters,
+                    execute_tool=execute_tool,
+                ),
+                handle_tool_error=True,
+                handle_validation_error=True,
+            ),
+        )
+
+    def wrap_tools(
+        self,
+        tools: t.Sequence[Tool],
+        execute_tool: AgenticProviderExecuteFn,
+    ) -> t.List[StructuredTool]:
+        """
+        Get composio tools wrapped as Langchain StructuredTool objects.
+        """
+        return [self.wrap_tool(tool=tool, execute_tool=execute_tool) for tool in tools]

composio_langgraph-0.10.5.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: composio-langgraph
+Version: 0.10.5
+Summary: Use Composio to get array of tools with LangGraph Agent Workflows.
+Home-page: https://github.com/ComposioHQ/composio
+Author: composio
+Author-email: Composio <tech@composio.dev>
+Project-URL: Homepage, https://github.com/ComposioHQ/composio
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9,<4
+Description-Content-Type: text/markdown
+Requires-Dist: langgraph
+Requires-Dist: composio
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+## 🦜🕸️ Using Composio With LangGraph
+
+Integrate Composio with LangGraph Agentic workflows & enable them to interact seamlessly with external apps, enhancing their functionality and reach.
+
+### Goal
+
+- **Star a repository on GitHub** using natural language commands through a LangGraph Agent.
+
+### Installation and Setup
+
+Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.
+
+```bash
+# Install Composio LangGraph package
+pip install composio-langgraph
+
+# Connect your GitHub account
+composio-cli add github
+
+# View available applications you can connect with
+composio-cli show-apps
+```
+
+### Usage Steps
+
+#### 1. Import Base Packages
+
+Prepare your environment by initializing necessary imports from LangGraph & LangChain for setting up your agent.
+
+```python
+from typing import Literal
+
+from langchain_openai import ChatOpenAI
+from langgraph.graph import MessagesState, StateGraph
+from langgraph.prebuilt import ToolNode
+```
+
+#### 2. Fetch GitHub LangGraph Tools via Composio
+
+Access GitHub tools provided by Composio for LangGraph, initialize a `ToolNode` with necessary tools obtaned from `ComposioToolSet`.
+
+```python
+from composio_langgraph import Action, ComposioToolSet
+
+# Initialize the toolset for GitHub
+composio_toolset = ComposioToolSet()
+tools = composio_toolset.get_actions(
+    actions=[
+        Action.GITHUB_ACTIVITY_STAR_REPO_FOR_AUTHENTICATED_USER,
+        Action.GITHUB_USERS_GET_AUTHENTICATED,
+    ])
+tool_node = ToolNode(tools)
+```
+
+#### 3. Prepare the model
+
+Initialize the LLM class and bind obtained tools to the model.
+
+```python
+model = ChatOpenAI(temperature=0, streaming=True)
+model_with_tools = model.bind_tools(functions)
+```
+#### 4. Define the Graph Nodes
+
+LangGraph expects you to define different nodes of the agentic workflow as separate functions. Here we define a node for calling the LLM model.
+
+```python
+def call_model(state: MessagesState):
+    messages = state["messages"]
+    response = model_with_tools.invoke(messages)
+    return {"messages": [response]}
+```
+#### 5. Define the Graph Nodes and Edges
+
+To establish the agent's workflow, we begin by initializing the workflow with `agent` and `tools` node, followed by specifying the connecting edges between nodes, finally compiling the workflow. These edges can be straightforward or conditional, depending on the workflow requirements.
+
+```python
+def should_continue(state: MessagesState) -> Literal["tools", "__end__"]:
+    messages = state["messages"]
+    last_message = messages[-1]
+    if last_message.tool_calls:
+        return "tools"
+    return "__end__"
+
+
+workflow = StateGraph(MessagesState)
+
+# Define the two nodes we will cycle between
+workflow.add_node("agent", call_model)
+workflow.add_node("tools", tool_node)
+
+workflow.add_edge("__start__", "agent")
+workflow.add_conditional_edges(
+    "agent",
+    should_continue,
+)
+workflow.add_edge("tools", "agent")
+
+app = workflow.compile()
+```
+#### 6. Invoke & Check Response
+
+After the compilation of workflow, we invoke the LLM with a task, and stream the response.
+
+```python
+for chunk in app.stream(
+    {
+        "messages": [
+            (
+                "human",
+                # "Star the Github Repository composiohq/composio",
+                "Get my information.",
+            )
+        ]
+    },
+    stream_mode="values",
+):
+    chunk["messages"][-1].pretty_print()
+```

composio_langgraph-0.10.5.dist-info/RECORD

@@ -0,0 +1,7 @@
+composio_langgraph/__init__.py,sha256=UmBCWVwsgGM4UCdYf0bxQ6byIkifzDZ_LFYLyWzRODs,74
+composio_langgraph/provider.py,sha256=Unomz2dvgpfPUJs5vZGpkmEg3kWlRBnTACz5yQxlaaQ,2959
+composio_langgraph/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+composio_langgraph-0.10.5.dist-info/METADATA,sha256=oLUbKgbIheTd__I_wcngUktT3HM9bGVC4qfMC7rS368,4068
+composio_langgraph-0.10.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+composio_langgraph-0.10.5.dist-info/top_level.txt,sha256=fT5qLVROO6_k0FCyW8_fOkGRJc_lxwWX-c6R6kN-llc,19
+composio_langgraph-0.10.5.dist-info/RECORD,,

{composio_langgraph-0.3.28.dist-info → composio_langgraph-0.10.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (71.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

composio_langgraph/toolset.py

@@ -1,124 +0,0 @@
-import typing as t
-
-from composio import WorkspaceConfigType
-from composio.constants import DEFAULT_ENTITY_ID
-
-from composio_langchain import ComposioToolSet as BaseComposioToolSet
-
-
-class ComposioToolSet(BaseComposioToolSet):
-    """
-    Composio toolset for LangGraph framework.
-
-    Example:
-    ```python
-    import json
-    import operator
-    from typing import Annotated, TypedDict, Sequence
-
-    from langchain_openai import ChatOpenAI
-    from langchain_core.utils.function_calling import convert_to_openai_function
-    from langchain_core.messages import BaseMessage, HumanMessage, FunctionMessage
-
-    from langgraph.graph import StateGraph, END
-    from langgraph.prebuilt import ToolInvocation, ToolExecutor
-    from composio_langgraph import Action, ComposioToolSet
-
-    composio_toolset = ComposioToolSet()
-    tools = composio_toolset.get_actions(
-        actions=[Action.GITHUB_ACTIVITY_STAR_REPO_FOR_AUTHENTICATED_USER]
-    )
-    tool_executor = ToolExecutor(tools)
-    functions = [convert_to_openai_function(t) for t in tools]
-
-    model = ChatOpenAI(temperature=0, streaming=True)
-    model = model.bind_functions(functions)
-
-
-    def function_1(state):
-        messages = state['messages']
-        response = model.invoke(messages)
-        return {"messages": [response]}
-
-
-    def function_2(state):
-        messages = state['messages']
-        last_message = messages[-1]
-        parsed_function_call = last_message.additional_kwargs["function_call"]
-
-        action = ToolInvocation(
-            tool=parsed_function_call["name"],
-            tool_input=json.loads(parsed_function_call["arguments"]),
-        )
-
-        # We call the tool_executor and get back a response
-        response = tool_executor.invoke(action)
-
-        # We use the response to create a FunctionMessage
-        function_message = FunctionMessage(
-            content=str(response),
-            name=action.tool
-            )
-
-        return {"messages": [function_message]}
-
-
-    def where_to_go(state):
-        messages = state['messages']
-        last_message = messages[-1]
-
-        if "function_call" in last_message.additional_kwargs:
-            return "continue"
-        else:
-            return "end"
-
-
-    class AgentState(TypedDict):
-        messages: Annotated[Sequence[BaseMessage], operator.add]
-
-
-    workflow = StateGraph(AgentState)
-    workflow.add_node("agent", function_1)
-    workflow.add_node("tool", function_2)
-    workflow.add_conditional_edges(
-        "agent",
-        where_to_go,
-        {
-            "continue": "tool",
-            "end": END
-        }
-    )
-    workflow.add_edge('tool', 'agent')
-    workflow.set_entry_point("agent")
-
-    app = workflow.compile()
-    ```
-    """
-
-    def __init__(
-        self,
-        api_key: t.Optional[str] = None,
-        base_url: t.Optional[str] = None,
-        entity_id: str = DEFAULT_ENTITY_ID,
-        output_in_file: bool = False,
-        workspace_config: t.Optional[WorkspaceConfigType] = None,
-        workspace_id: t.Optional[str] = None,
-    ) -> None:
-        """
-        Initialize composio toolset.
-
-        :param api_key: Composio API key
-        :param base_url: Base URL for the Composio API server
-        :param entity_id: Entity ID for making function calls
-        :param output_in_file: Whether to write output to a file
-        """
-        super().__init__(
-            api_key=api_key,
-            base_url=base_url,
-            entity_id=entity_id,
-            output_in_file=output_in_file,
-            workspace_config=workspace_config,
-            workspace_id=workspace_id,
-        )
-
-        self._runtime = "langgraph"

composio_langgraph-0.3.28.dist-info/METADATA

@@ -1,164 +0,0 @@
-Metadata-Version: 2.1
-Name: composio_langgraph
-Version: 0.3.28
-Summary: Use Composio to get array of tools with LnagGraph Agent Workflows
-Home-page: https://github.com/ComposioHQ/composio
-Author: Sawradip
-Author-email: sawradip@composio.dev
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9,<4
-Description-Content-Type: text/markdown
-Requires-Dist: langchain-core >=0.2.17
-Requires-Dist: composio-langchain ==0.3.28
-
-## 🦜🕸️ Using Composio With LangGraph
-
-Integrate Composio with LangGraph Agentic workflows & enable them to interact seamlessly with external apps, enhancing their functionality and reach.
-
-### Goal
-
-- **Star a repository on GitHub** using natural language commands through a LangGraph Agent.
-
-### Installation and Setup
-
-Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.
-
-```bash
-# Install Composio LangGraph package
-pip install composio-langgraph
-
-# Connect your GitHub account
-composio-cli add github
-
-# View available applications you can connect with
-composio-cli show-apps
-```
-
-### Usage Steps
-
-#### 1. Import Base Packages
-
-Prepare your environment by initializing necessary imports from LangGraph & LangChain for setting up your agent.
-
-```python
-from langchain.agents import create_openai_functions_agent, AgentExecutor
-import json
-import operator
-from typing import Annotated, TypedDict, Sequence
-
-from langchain_openai import ChatOpenAI
-from langchain_core.utils.function_calling import convert_to_openai_function
-from langchain_core.messages import BaseMessage, HumanMessage, FunctionMessage
-
-from langgraph.graph import StateGraph, END
-from langgraph.prebuilt import ToolInvocation, ToolExecutor
-```
-
-#### 2. Fetch GitHub LangGraph Tools via Composio
-
-Access GitHub tools provided by Composio for LangGraph, initialize a `tool_executor` and get OpenAI-format function schemas from the tools.
-
-```python
-from composio_langgraph import Action, ComposioToolSet
-
-# Initialize the toolset for GitHub
-composio_toolset = ComposioToolSet()
-tools = composio_toolset.get_actions(
-    actions=[Action.GITHUB_ACTIVITY_STAR_REPO_FOR_AUTHENTICATED_USER]
-)
-tool_executor = ToolExecutor(tools)
-functions = [convert_to_openai_function(t) for t in tools]
-```
-
-#### 3. Prepare the model
-
-Initialize the LLM class and bind obtained functions to the model.
-
-```python
-model = ChatOpenAI(temperature=0, streaming=True)
-model = model.bind_functions(functions)
-```
-#### 4. Define the Graph Nodes
-
-LangGraph expects you to define different nodes of the agentic workflow as separate functions. 
-
-Here we define one node for calling the LLM and another for executing the correct tool(function), with appropriate parameters.
-
-```python
-def function_1(state):
-    messages = state['messages']
-    response = model.invoke(messages)
-    return {"messages": [response]}
-
-
-def function_2(state):
-    messages = state['messages']
-    last_message = messages[-1]
-
-    parsed_function_call = last_message.additional_kwargs["function_call"]
-
-    action = ToolInvocation(
-        tool=parsed_function_call["name"],
-        tool_input=json.loads(parsed_function_call["arguments"]),
-    )
-
-    response = tool_executor.invoke(action)
-
-    function_message = FunctionMessage(content=str(response), name=action.tool)
-
-    return {"messages": [function_message]}
-
-```
-#### 5. Define the Graph Edges
-
-To establish the agent's workflow, we begin by initializing the workflow with an `AgentState` to maintain state, followed by specifying the connecting edges between nodes. These edges can be straightforward or conditional, depending on the workflow requirements.
-
-```python
-
-def where_to_go(state):
-    messages = state['messages']
-    last_message = messages[-1]
-
-    if "function_call" in last_message.additional_kwargs:
-        return "continue"
-    else:
-        return "end"
-
-
-class AgentState(TypedDict):
-    messages: Annotated[Sequence[BaseMessage], operator.add]
-
-
-workflow = StateGraph(AgentState)
-workflow.add_node("agent", function_1)
-workflow.add_node("tool", function_2)
-workflow.add_conditional_edges(
-    "agent",
-    where_to_go,
-    {
-        "continue": "tool",
-        "end": END
-    }
-)
-workflow.add_edge('tool', 'agent')
-workflow.set_entry_point("agent")
-
-app = workflow.compile()
-```
-#### 6. Invoke & Check Response
-
-After the compilation of workflow, we invoke the LLM with a task, and print the final response. 
-
-```python
-inputs = {
-    "messages": [
-        HumanMessage(
-            content="Star the Github repository sawradip/sawradip"
-            )
-        ]
-    }
-response = app.invoke(inputs)
-print(response)
-```

composio_langgraph-0.3.28.dist-info/RECORD

@@ -1,6 +0,0 @@
-composio_langgraph/__init__.py,sha256=sjr9YY5lPNx-vI75_pmbFgPWUaEuh0WIUozsskDlQOE,211
-composio_langgraph/toolset.py,sha256=Ud3wFuFIiOm4InjhiNZGSjLzUElDL1YR84LEsOEyb88,3625
-composio_langgraph-0.3.28.dist-info/METADATA,sha256=_Un_fuNZaX0MHSPYJ0odHsNB9y76fZw1A8FK8LvAYLw,4758
-composio_langgraph-0.3.28.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
-composio_langgraph-0.3.28.dist-info/top_level.txt,sha256=fT5qLVROO6_k0FCyW8_fOkGRJc_lxwWX-c6R6kN-llc,19
-composio_langgraph-0.3.28.dist-info/RECORD,,