llamaindex agent

.gitignore

@@ -0,0 +1 @@
+env*

.python-version

@@ -0,0 +1 @@
+3.13

agents.py

@@ -0,0 +1,104 @@
+import os
+import random
+import asyncio
+from dotenv import load_dotenv
+from llama_index.core.agent.workflow import AgentWorkflow
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
+# from opentelemetry.sdk import trace as trace_sdk
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from langfuse import get_client
+from rich.pretty import pprint
+
+
+
+
+import base64
+
+
+
+# Import tool functions and initializers from tools.py
+from tools import (
+    get_tavily_tool,
+    get_arxiv_reader,
+    get_wikipedia_reader,
+    get_wikipedia_tool,
+    get_arxiv_tool,
+    get_search_tool,
+    get_calculator_tool,
+    get_hub_stats_tool,
+    get_hub_stats,
+)
+
+load_dotenv("env.local")
+
+class AlfredAgent:
+    def __init__(self):
+        # Tool initializations using imported functions
+        self.tavily_tool = get_tavily_tool()
+        self.arxiv_reader = get_arxiv_reader()
+        self.wikipedia_reader = get_wikipedia_reader()
+        self.wikipedia_tool = get_wikipedia_tool(self.wikipedia_reader)
+        self.arxiv_tool = get_arxiv_tool(self.arxiv_reader)
+        self.search_tool = get_search_tool()
+        self.calculator_tool = get_calculator_tool()
+        self.hub_stats_tool = get_hub_stats_tool()
+        # LLM and agent workflow
+        self.llm = HuggingFaceInferenceAPI(model_name="Qwen/Qwen2.5-Coder-32B-Instruct")
+        self.alfred = AgentWorkflow.from_tools_or_functions(
+            [*self.search_tool, *self.calculator_tool, self.wikipedia_tool, self.arxiv_tool, self.hub_stats_tool],
+            llm=self.llm
+        )
+
+        LANGFUSE_AUTH=base64.b64encode(f"{os.getenv('LANGFUSE_PUBLIC_KEY')}:{os.getenv('LANGFUSE_SECRET_KEY')}".encode()).decode()
+        os.environ['OTEL_EXPORTER_OTLP_ENDPOINT'] = os.environ.get("LANGFUSE_HOST") + "/api/public/otel"
+        os.environ['OTEL_EXPORTER_OTLP_HEADERS'] = f"Authorization=Basic {LANGFUSE_AUTH}"
+
+        # Set up OpenTelemetry tracing
+        self.tracer_provider = TracerProvider()
+        self.tracer_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter()))
+        trace.set_tracer_provider(self.tracer_provider)
+
+
+        self.instrumentor = LlamaIndexInstrumentor(
+            public_key=os.getenv("LANGFUSE_PUBLIC_KEY"), 
+            secret_key=os.getenv("LANGFUSE_SECRET_KEY"), 
+            host=os.environ.get("LANGFUSE_HOST")
+        )
+        
+
+    async def run_query(self, query: str):
+        # Instrument LlamaIndex with OpenTelemetry
+        self.instrumentor.instrument()
+
+        langfuse = get_client()  # This picks up your LANGFUSE_PUBLIC_KEY, etc.
+
+        # Now, wrap your LlamaIndex calls in a Langfuse span for trace context
+        with langfuse.start_as_current_span(name="llamaindex-query") as span:
+            # Optionally set trace attributes
+            span.update_trace(user_id="user_123", input={"query": query})
+
+            response = await self.alfred.run(query)
+
+            # Optionally set trace output
+            span.update_trace(output={"response": str(response)})
+
+        # For short-lived scripts, flush before exit
+        langfuse.flush()
+        self.tracer_provider.shutdown()
+        return response
+
+def main():
+    
+    agent = AlfredAgent()
+    query = "who is the capital of France?"
+    print(f"Running query: {query}")
+    response = asyncio.run(agent.run_query(query))
+    print("\n🎩 Agents's Response:")
+    pprint(response)
+
+if __name__ == "__main__":
+    main()

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from final-assignment-template!")
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "final-assignment-template"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "dotenv>=0.9.9",
+    "huggingface-hub>=0.32.4",
+    "langfuse>=3.0.0",
+    "llama-index>=0.12.40",
+    "llama-index-core>=0.12.40",
+    "llama-index-llms-huggingface-api>=0.5.0",
+    "llama-index-readers-papers>=0.3.2",
+    "llama-index-readers-wikipedia>=0.3.0",
+    "llama-index-tools-duckduckgo>=0.3.0",
+    "llama-index-tools-tavily-research>=0.3.0",
+    "rich>=14.0.0",
+    "wikipedia>=1.4.0",
+]

tools.py

@@ -0,0 +1,89 @@
+import os
+from llama_index.core.tools import FunctionTool
+from llama_index.tools.tavily_research import TavilyToolSpec
+from llama_index.readers.wikipedia import WikipediaReader
+from llama_index.readers.papers import ArxivReader
+from llama_index.core.tools.ondemand_loader_tool import OnDemandLoaderTool
+from huggingface_hub import list_models
+
+# Math functions
+
+def multiply(a: int, b: int) -> int:
+    """Multiply two numbers."""
+    return a * b
+
+def add(a: int, b: int) -> int:
+    """Add two numbers."""
+    return a + b
+
+def subtract(a: int, b: int) -> int:
+    """Subtract two numbers."""
+    return a - b
+
+def divide(a: int, b: int) -> int:
+    """Divide two numbers."""
+    if b == 0:
+        raise ValueError("Cannot divide by zero.")
+    return a / b
+
+def modulus(a: int, b: int) -> int:
+    """Get the modulus of two numbers."""
+    return a % b
+
+# Hugging Face Hub stats tool
+
+def get_hub_stats(author: str) -> str:
+    """Fetches the most downloaded model from a specific author on the Hugging Face Hub."""
+    try:
+        models = list(list_models(author=author, sort="downloads", direction=-1, limit=1))
+        if models:
+            model = models[0]
+            return f"The most downloaded model by {author} is {model.id} with {model.downloads:,} downloads."
+        else:
+            return f"No models found for author {author}."
+    except Exception as e:
+        return f"Error fetching models for {author}: {str(e)}"
+
+# Tool initializations (as functions to be called in agent)
+
+def get_tavily_tool():
+    return TavilyToolSpec(api_key=os.getenv("TAVILY_API_KEY"))
+
+def get_arxiv_reader():
+    return ArxivReader()
+
+def get_wikipedia_reader():
+    return WikipediaReader()
+
+def get_wikipedia_tool(wikipedia_reader=None):
+    if wikipedia_reader is None:
+        wikipedia_reader = get_wikipedia_reader()
+    return OnDemandLoaderTool.from_defaults(
+        wikipedia_reader,
+        name="Wikipedia Tool",
+        description="A tool for loading data and querying articles from Wikipedia",
+    )
+
+def get_arxiv_tool(arxiv_reader=None):
+    if arxiv_reader is None:
+        arxiv_reader = get_arxiv_reader()
+    return OnDemandLoaderTool.from_defaults(
+        arxiv_reader,
+        name="Arxiv Tool",
+        description="A tool for loading data and querying articles from Arxiv",
+    )
+
+def get_search_tool():
+    return get_tavily_tool().to_tool_list()
+
+def get_calculator_tool():
+    return [
+        FunctionTool.from_defaults(multiply),
+        FunctionTool.from_defaults(add),
+        FunctionTool.from_defaults(subtract),
+        FunctionTool.from_defaults(divide),
+        FunctionTool.from_defaults(modulus),
+    ]
+
+def get_hub_stats_tool():
+    return FunctionTool.from_defaults(get_hub_stats)