Définir un ensemble clair de Tools est crucial pour la performance. Comme nous l’avons discuté dans l’unité 1, des interfaces de tools claires sont plus faciles à utiliser pour les LLMs. Tout comme une interface API logicielle pour les ingénieurs humains, ils peuvent tirer plus de profit de l’outil s’il est facile de comprendre comment il fonctionne.
Il y a quatre types principaux de tools dans LlamaIndex :

FunctionTool : Convertit n’importe quelle fonction Python en un tool qu’un agent peut utiliser. Il comprend automatiquement comment la fonction fonctionne.QueryEngineTool : Un tool qui permet aux agents d’utiliser des query engines. Puisque les agents sont construits sur des query engines, ils peuvent également utiliser d’autres agents comme tools.Toolspecs : Ensembles de tools créés par la communauté, qui incluent souvent des tools pour des services spécifiques comme Gmail.Utility Tools : Tools spéciaux qui aident à gérer de grandes quantités de données d’autres tools.Nous passerons en revue chacun d’eux plus en détail ci-dessous.
Un FunctionTool fournit un moyen simple d’envelopper n’importe quelle fonction Python et de la rendre disponible à un agent.
Vous pouvez passer soit une fonction synchrone soit asynchrone au tool, avec des paramètres optionnels name et description.
Le nom et la description sont particulièrement importants car ils aident l’agent à comprendre quand et comment utiliser le tool efficacement.
Regardons comment créer un FunctionTool ci-dessous puis l’appeler.
from llama_index.core.tools import FunctionTool
def get_weather(location: str) -> str:
"""Useful for getting the weather for a given location."""
print(f"Getting weather for {location}")
return f"The weather in {location} is sunny"
tool = FunctionTool.from_defaults(
get_weather,
name="my_weather_tool",
description="Useful for getting the weather for a given location.",
)
tool.call("New York")Le QueryEngine que nous avons défini dans l’unité précédente peut être facilement transformé en un tool en utilisant la classe QueryEngineTool.
Voyons comment créer un QueryEngineTool à partir d’un QueryEngine dans l’exemple ci-dessous.
from llama_index.core import VectorStoreIndex
from llama_index.core.tools import QueryEngineTool
from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.vector_stores.chroma import ChromaVectorStore
embed_model = HuggingFaceEmbedding("BAAI/bge-small-en-v1.5")
db = chromadb.PersistentClient(path="./alfred_chroma_db")
chroma_collection = db.get_or_create_collection("alfred")
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
index = VectorStoreIndex.from_vector_store(vector_store, embed_model=embed_model)
llm = HuggingFaceInferenceAPI(model_name="Qwen/Qwen2.5-Coder-32B-Instruct")
query_engine = index.as_query_engine(llm=llm)
tool = QueryEngineTool.from_defaults(query_engine, name="some useful name", description="some useful description")Pensez aux ToolSpecs comme des collections de tools qui fonctionnent ensemble harmonieusement - comme une toolkit professionnelle bien organisée.
Tout comme la toolkit d’un mécanicien contient des tools complémentaires qui fonctionnent ensemble pour les réparations de véhicules, un ToolSpec combine des tools apparentés pour des objectifs spécifiques.
Par exemple, le ToolSpec d’un agent comptable pourrait intégrer élégamment des capacités de tableur, des fonctionnalités email et des tools de calcul pour gérer les tâches financières avec précision et efficacité.
pip install llama-index-tools-google
Et maintenant nous pouvons charger le toolspec et le convertir en une liste de tools.
from llama_index.tools.google import GmailToolSpec
tool_spec = GmailToolSpec()
tool_spec_list = tool_spec.to_tool_list()Pour obtenir une vue plus détaillée des tools, nous pouvons examiner les metadata de chaque tool.
[(tool.metadata.name, tool.metadata.description) for tool in tool_spec_list]LlamaIndex permet également d’utiliser les tools MCP grâce à un ToolSpec sur le LlamaHub. Vous pouvez simplement lancer un serveur MCP et commencer à l’utiliser grâce à l’implémentation suivante.
Si vous voulez approfondir MCP, vous pouvez consulter notre cours MCP gratuit.
pip install llama-index-tools-mcp
from llama_index.tools.mcp import BasicMCPClient, McpToolSpec
# We consider there is a mcp server running on 127.0.0.1:8000, or you can use the mcp client to connect to your own mcp server.
mcp_client = BasicMCPClient("http://127.0.0.1:8000/sse")
mcp_tool = McpToolSpec(client=mcp_client)
# get the agent
agent = await get_agent(mcp_tool)
# create the agent context
agent_context = Context(agent)Souvent, interroger directement une API peut retourner une quantité excessive de données, dont certaines peuvent être non pertinentes, déborder la fenêtre de contexte du LLM, ou augmenter inutilement le nombre de tokens que vous utilisez. Passons en revue nos deux utility tools principaux ci-dessous.
OnDemandToolLoader : Ce tool transforme n’importe quel data loader LlamaIndex existant (classe BaseReader) en un tool qu’un agent peut utiliser. Le tool peut être appelé avec tous les paramètres nécessaires pour déclencher load_data du data loader, ainsi qu’une chaîne de requête en langage naturel. Pendant l’exécution, nous chargeons d’abord les données du data loader, les indexons (par exemple avec un vector store), puis les interrogeons ‘à la demande’. Ces trois étapes se produisent dans un seul appel de tool.LoadAndSearchToolSpec : Le LoadAndSearchToolSpec prend n’importe quel Tool existant en entrée. En tant que tool spec, il implémente to_tool_list, et quand cette fonction est appelée, deux tools sont retournés : un tool de chargement puis un tool de recherche. L’exécution du Tool de chargement appellerait le Tool sous-jacent, puis indexerait la sortie (par défaut avec un vector index). L’exécution du Tool de recherche prendrait une chaîne de requête en entrée et appellerait l’index sous-jacent.Maintenant que nous comprenons les bases des agents et des tools dans LlamaIndex, voyons comment nous pouvons utiliser LlamaIndex pour créer des workflows configurables et gérables !
< > Update on GitHub