composio-langgraph 0.3.30__tar.gz → 0.4.1__tar.gz

composio_langgraph-0.4.1/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.1
+Name: composio_langgraph
+Version: 0.4.1
+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: composio_langchain==0.4.1
+Requires-Dist: langgraph
+
+## 🦜🕸️ 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.4.1/README.md

@@ -0,0 +1,119 @@
+## 🦜🕸️ 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.3.30 → composio_langgraph-0.4.1}/composio_langgraph/toolset.py

@@ -26,7 +26,7 @@ class ComposioToolSet(BaseComposioToolSet):
 
     composio_toolset = ComposioToolSet()
     tools = composio_toolset.get_actions(
-        actions=[Action.GITHUB_ACTIVITY_STAR_REPO_FOR_AUTHENTICATED_USER]
+        actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
     )
     tool_executor = ToolExecutor(tools)
     functions = [convert_to_openai_function(t) for t in tools]

composio_langgraph-0.4.1/composio_langgraph.egg-info/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.1
+Name: composio_langgraph
+Version: 0.4.1
+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: composio_langchain==0.4.1
+Requires-Dist: langgraph
+
+## 🦜🕸️ 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.4.1/composio_langgraph.egg-info/requires.txt

@@ -0,0 +1,2 @@
+composio_langchain==0.4.1
+langgraph

{composio_langgraph-0.3.30 → composio_langgraph-0.4.1}/setup.py

@@ -9,7 +9,7 @@ from setuptools import setup
 
 setup(
     name="composio_langgraph",
-    version="0.3.30",
+    version="0.4.1",
     author="Sawradip",
     author_email="sawradip@composio.dev",
     description="Use Composio to get array of tools with LnagGraph Agent Workflows",
@@ -23,8 +23,8 @@ setup(
     ],
     python_requires=">=3.9,<4",
     install_requires=[
-        "langchain_core>=0.2.17",
-        "composio_langchain==0.3.30",
+        "composio_langchain==0.4.1",
+        "langgraph",
     ],
     include_package_data=True,
 )

composio_langgraph-0.3.30/PKG-INFO

@@ -1,164 +0,0 @@
-Metadata-Version: 2.1
-Name: composio_langgraph
-Version: 0.3.30
-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.30
-
-## 🦜🕸️ 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.30/README.md

@@ -1,149 +0,0 @@
-## 🦜🕸️ 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.30/composio_langgraph.egg-info/PKG-INFO

@@ -1,164 +0,0 @@
-Metadata-Version: 2.1
-Name: composio_langgraph
-Version: 0.3.30
-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.30
-
-## 🦜🕸️ 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.30/composio_langgraph.egg-info/requires.txt

@@ -1,2 +0,0 @@
-langchain_core>=0.2.17
-composio_langchain==0.3.30