fix llamaindex readme

Author: twishabansal

packages/toolbox-langchain/README.md

@@ -1,8 +1,8 @@
 ![MCP Toolbox Logo](https://raw.githubusercontent.com/googleapis/genai-toolbox/main/logo.png)
-# MCP Toolbox LangChain SDK
+# MCP Toolbox LlamaIndex SDK
 
 This SDK allows you to seamlessly integrate the functionalities of
-[Toolbox](https://github.com/googleapis/genai-toolbox) into your LangChain LLM
+[Toolbox](https://github.com/googleapis/genai-toolbox) into your LlamaIndex LLM
 applications, enabling advanced orchestration and interaction with GenAI models.
 
 <!-- TOC ignore:true -->
@@ -15,10 +15,7 @@ applications, enabling advanced orchestration and interaction with GenAI models.
 - [Loading Tools](#loading-tools)
     - [Load a toolset](#load-a-toolset)
     - [Load a single tool](#load-a-single-tool)
-- [Use with LangChain](#use-with-langchain)
-- [Use with LangGraph](#use-with-langgraph)
-    - [Represent Tools as Nodes](#represent-tools-as-nodes)
-    - [Connect Tools with LLM](#connect-tools-with-llm)
+- [Use with LlamaIndex](#use-with-llamaindex)
 - [Manual usage](#manual-usage)
 - [Authenticating Tools](#authenticating-tools)
     - [Supported Authentication Mechanisms](#supported-authentication-mechanisms)
@@ -38,41 +35,48 @@ applications, enabling advanced orchestration and interaction with GenAI models.
 ## Installation
 
 ```bash
-pip install toolbox-langchain
+pip install toolbox-llamaindex
 ```
 
 ## Quickstart
 
 Here's a minimal example to get you started using
-[LangGraph](https://langchain-ai.github.io/langgraph/reference/prebuilt/#langgraph.prebuilt.chat_agent_executor.create_react_agent):
+# TODO: add link
+[LlamaIndex]():
 
 ```py
-from toolbox_langchain import ToolboxClient
-from langchain_google_vertexai import ChatVertexAI
-from langgraph.prebuilt import create_react_agent
+import asyncio
 
-toolbox = ToolboxClient("http://127.0.0.1:5000")
-tools = toolbox.load_toolset()
+from llama_index.llms.google_genai import GoogleGenAI
+from llama_index.core.agent.workflow import AgentWorkflow
+
+from toolbox_llamaindex import ToolboxClient
 
-model = ChatVertexAI(model="gemini-1.5-pro-002")
-agent = create_react_agent(model, tools)
+async def run_agent():
+  toolbox = ToolboxClient("http://127.0.0.1:5000")
+  tools = toolbox.load_toolset()
 
-prompt = "How's the weather today?"
+  vertex_model = GoogleGenAI(
+      model="gemini-1.5-pro",
+      vertexai_config={"project": "project-id", "location": "us-central1"},
+  )
+  agent = AgentWorkflow.from_tools_or_functions(
+      tools,
+      llm=vertex_model,
+      system_prompt="You are a helpful assistant.",
+  )
+  response = await agent.run(user_msg="Get some response from the agent.")
+  print(response)
 
-for s in agent.stream({"messages": [("user", prompt)]}, stream_mode="values"):
-    message = s["messages"][-1]
-    if isinstance(message, tuple):
-        print(message)
-    else:
-        message.pretty_print()
+asyncio.run(run_agent())
 ```
 
 ## Usage
 
 Import and initialize the toolbox client.
 
 ```py
-from toolbox_langchain import ToolboxClient
+from toolbox_llamaindex import ToolboxClient
 
 # Replace with your Toolbox service's URL
 toolbox = ToolboxClient("http://127.0.0.1:5000")
@@ -102,85 +106,63 @@ tool = toolbox.load_tool("my-tool")
 Loading individual tools gives you finer-grained control over which tools are
 available to your LLM agent.
 
-## Use with LangChain
+## Use with LlamaIndex
 
 LangChain's agents can dynamically choose and execute tools based on the user
 input. Include tools loaded from the Toolbox SDK in the agent's toolkit:
 
 ```py
-from langchain_google_vertexai import ChatVertexAI
+from llama_index.llms.google_genai import GoogleGenAI
+from llama_index.core.agent.workflow import AgentWorkflow
 
-model = ChatVertexAI(model="gemini-1.5-pro-002")
+vertex_model = GoogleGenAI(
+    model="gemini-1.5-pro",
+    vertexai_config={"project": "project-id", "location": "us-central1"},
+)
 
 # Initialize agent with tools
-agent = model.bind_tools(tools)
-
-# Run the agent
-result = agent.invoke("Do something with the tools")
-```
-
-## Use with LangGraph
-
-Integrate the Toolbox SDK with LangGraph to use Toolbox service tools within a
-graph-based workflow. Follow the [official
-guide](https://langchain-ai.github.io/langgraph/) with minimal changes.
-
-### Represent Tools as Nodes
-
-Represent each tool as a LangGraph node, encapsulating the tool's execution within the node's functionality:
-
-```py
-from toolbox_langchain import ToolboxClient
-from langgraph.graph import StateGraph, MessagesState
-from langgraph.prebuilt import ToolNode
-
-# Define the function that calls the model
-def call_model(state: MessagesState):
-    messages = state['messages']
-    response = model.invoke(messages)
-    return {"messages": [response]}  # Return a list to add to existing messages
-
-model = ChatVertexAI(model="gemini-1.5-pro-002")
-builder = StateGraph(MessagesState)
-tool_node = ToolNode(tools)
-
-builder.add_node("agent", call_model)
-builder.add_node("tools", tool_node)
+agent = AgentWorkflow.from_tools_or_functions(
+    tools,
+    llm=vertex_model,
+    system_prompt="You are a helpful assistant.",
+)
+
+# Query the agent
+response = await agent.run(user_msg="Get some response from the agent.")
+print(response)
 ```
 
-### Connect Tools with LLM
+### Maintain state
 
-Connect tool nodes with LLM nodes. The LLM decides which tool to use based on
-input or context. Tool output can be fed back into the LLM:
+To maintain state for the agent, add context as follows:
 
 ```py
-from typing import Literal
-from langgraph.graph import END, START
-from langchain_core.messages import HumanMessage
-
-# Define the function that determines whether to continue or not
-def should_continue(state: MessagesState) -> Literal["tools", END]:
-    messages = state['messages']
-    last_message = messages[-1]
-    if last_message.tool_calls:
-        return "tools"  # Route to "tools" node if LLM makes a tool call
-    return END  # Otherwise, stop
-
-builder.add_edge(START, "agent")
-builder.add_conditional_edges("agent", should_continue)
-builder.add_edge("tools", 'agent')
-
-graph = builder.compile()
-
-graph.invoke({"messages": [HumanMessage(content="Do something with the tools")]})
+from llama_index.core.agent.workflow import AgentWorkflow
+from llama_index.core.workflow import Context
+from llama_index.llms.google_genai import GoogleGenAI
+
+vertex_model = GoogleGenAI(
+    model="gemini-1.5-pro",
+    vertexai_config={"project": "twisha-dev", "location": "us-central1"},
+)
+agent = AgentWorkflow.from_tools_or_functions(
+    tools,
+    llm=vertex_model,
+    system_prompt="You are a helpful assistant",
+)
+
+# Save memory in agent context
+ctx = Context(agent)
+response = await agent.run(user_msg="Give me some response.", ctx=ctx)
+print(response)
 ```
 
 ## Manual usage
 
-Execute a tool manually using the `invoke` method:
+Execute a tool manually using the `call` method:
 
 ```py
-result = tools[0].invoke({"name": "Alice", "age": 30})
+result = tools[0].call({"name": "Alice", "age": 30})
 ```
 
 This is useful for testing tools or when you need precise control over tool
@@ -250,7 +232,7 @@ auth_tools = toolbox.load_toolset(auth_tokens={"my_auth": get_auth_token})
 
 ```py
 import asyncio
-from toolbox_langchain import ToolboxClient
+from toolbox_llamaindex import ToolboxClient
 
 async def get_auth_token():
     # ... Logic to retrieve ID token (e.g., from local storage, OAuth flow)
@@ -261,7 +243,7 @@ toolbox = ToolboxClient("http://127.0.0.1:5000")
 tool = toolbox.load_tool("my-tool")
 
 auth_tool = tool.add_auth_token("my_auth", get_auth_token)
-result = auth_tool.invoke({"input": "some input"})
+result = auth_tool.call({"input": "some input"})
 print(result)
 ```
 
@@ -329,7 +311,7 @@ use the asynchronous interfaces of the `ToolboxClient`.
 
 ```py
 import asyncio
-from toolbox_langchain import ToolboxClient
+from toolbox_llamaindex import ToolboxClient
 
 async def main():
     toolbox = ToolboxClient("http://127.0.0.1:5000")