agentvis 0.1.0__tar.gz

agentvis-0.1.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: agentvis
+Version: 0.1.0
+Summary: Framework-agnostic reasoning trace visualization tool for AI agents.
+Author: Nitesh Kumar
+License: Apache License 2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: bm25s==0.3.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1.0; extra == "langchain"
+
+# agentvis
+
+<p align="center">
+  <picture align="center">
+    <img align="center" alt="agentvis logo" src="https://raw.githubusercontent.com/kumarniteshpersonal-beep/agentvis/968caea6e04577583d7d16f7015b9925362d5f53/packages/ui/public/agentvis_logo.svg" width="560">
+  </picture>
+</p>
+
+
+*agentvis* visualizes an agent’s reasoning trace, giving you clear insight into *why* the agent chose a particular path or triggered a specific tool call.  
+
+By exposing the influence flow behind each decision, it transforms opaque agent behavior into something understandable and actionable — so you can confidently refine and improve your prompts, which is often the hardest part of building reliable agents. 🧠✨
+
+## *agentvis* reasoning visualization example
+
+![flow_diagram](https://raw.githubusercontent.com/kumarniteshpersonal-beep/agentvis/refs/heads/main/packages/py/images/vis.png)
+
+## Installation
+
+Install core:
+
+```bash
+pip install agentvis
+```
+
+With LangChain support:
+
+```bash
+pip install agentvis[langchain]
+```
+
+
+## How to generate an agent reasoning graph
+
+### 1. Define your LangChain / LangGraph agent
+
+```python
+from langchain_tavily import TavilySearch
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.agents import create_agent
+from langchain.messages import HumanMessage
+import os
+
+os.environ["TAVILY_API_KEY"] = "<your-tavily-api-key>"
+
+tavily_search = TavilySearch(
+    max_results=5,
+    search_depth="basic",
+)
+
+llm = ChatGoogleGenerativeAI(
+    model="gemini-2.5-flash-lite",
+    temperature=0.7,
+    google_api_key="<your-google-api-key>",
+)
+
+agent = create_agent(
+    llm,
+    [tavily_search],
+    system_prompt=(
+        "You are a helpful web search agent. "
+        "Use the Tavily tool when you need fresh information from the web."
+    ),
+)
+
+result = agent.invoke(
+    {"messages": [HumanMessage("Top warm countries and weather of each.")]}
+)
+messages = result["messages"]
+```
+
+### 2. Build the reasoning graph with *agentvis* and get a shareable link in exchange of messages produced by agent
+
+```python
+from agentvis.framework.langchain import LangChainAdapter
+from agentvis.core.export import ExportFactory
+
+# Convert LLM messages into an AgentGraph
+graph = LangChainAdapter().build_agent_graph(messages)
+
+# Export as a short link you can open in the UI
+link = ExportFactory.export_graph(graph=graph, export_strategy="link")  # or "json"
+print(link)
+```
+
+> Open the printed `link` in your browser to inspect the full reasoning trace of the `websearch` agent. 
+
+## License
+
+This project is licensed under the Apache License 2.0.

agentvis-0.1.0/README.md

@@ -0,0 +1,90 @@
+# agentvis
+
+<p align="center">
+  <picture align="center">
+    <img align="center" alt="agentvis logo" src="https://raw.githubusercontent.com/kumarniteshpersonal-beep/agentvis/968caea6e04577583d7d16f7015b9925362d5f53/packages/ui/public/agentvis_logo.svg" width="560">
+  </picture>
+</p>
+
+
+*agentvis* visualizes an agent’s reasoning trace, giving you clear insight into *why* the agent chose a particular path or triggered a specific tool call.  
+
+By exposing the influence flow behind each decision, it transforms opaque agent behavior into something understandable and actionable — so you can confidently refine and improve your prompts, which is often the hardest part of building reliable agents. 🧠✨
+
+## *agentvis* reasoning visualization example
+
+![flow_diagram](https://raw.githubusercontent.com/kumarniteshpersonal-beep/agentvis/refs/heads/main/packages/py/images/vis.png)
+
+## Installation
+
+Install core:
+
+```bash
+pip install agentvis
+```
+
+With LangChain support:
+
+```bash
+pip install agentvis[langchain]
+```
+
+
+## How to generate an agent reasoning graph
+
+### 1. Define your LangChain / LangGraph agent
+
+```python
+from langchain_tavily import TavilySearch
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.agents import create_agent
+from langchain.messages import HumanMessage
+import os
+
+os.environ["TAVILY_API_KEY"] = "<your-tavily-api-key>"
+
+tavily_search = TavilySearch(
+    max_results=5,
+    search_depth="basic",
+)
+
+llm = ChatGoogleGenerativeAI(
+    model="gemini-2.5-flash-lite",
+    temperature=0.7,
+    google_api_key="<your-google-api-key>",
+)
+
+agent = create_agent(
+    llm,
+    [tavily_search],
+    system_prompt=(
+        "You are a helpful web search agent. "
+        "Use the Tavily tool when you need fresh information from the web."
+    ),
+)
+
+result = agent.invoke(
+    {"messages": [HumanMessage("Top warm countries and weather of each.")]}
+)
+messages = result["messages"]
+```
+
+### 2. Build the reasoning graph with *agentvis* and get a shareable link in exchange of messages produced by agent
+
+```python
+from agentvis.framework.langchain import LangChainAdapter
+from agentvis.core.export import ExportFactory
+
+# Convert LLM messages into an AgentGraph
+graph = LangChainAdapter().build_agent_graph(messages)
+
+# Export as a short link you can open in the UI
+link = ExportFactory.export_graph(graph=graph, export_strategy="link")  # or "json"
+print(link)
+```
+
+> Open the printed `link` in your browser to inspect the full reasoning trace of the `websearch` agent. 
+
+## License
+
+This project is licensed under the Apache License 2.0.

agentvis-0.1.0/agentvis/__init__.py

@@ -0,0 +1,10 @@
+"""
+Top-level package for the AgentVis Python library.
+
+The main, framework-agnostic APIs live under:
+
+- ``agentvis.core`` – graph model, export helpers, strategies
+- ``agentvis.framework`` – optional framework adapters (e.g. LangChain)
+"""
+
+__all__ = ["core", "framework"]

agentvis-0.1.0/agentvis/core/__init__.py

@@ -0,0 +1 @@
+from .main import BusinessLogic

agentvis-0.1.0/agentvis/core/connection_creation_strategy/__init__.py

@@ -0,0 +1,3 @@
+from .context import ContextConnectionCreation
+from .strategy_tool_to_tool import StrategyToolToTool
+from .base import ConnectionCreationStrategy

agentvis-0.1.0/agentvis/core/connection_creation_strategy/base.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from agentvis.core.models import Node, Connection
+
+class ConnectionCreationStrategy(ABC):
+    def __init__(self, nodes_matrix: list[list[Node]]):
+        self.nodes_matrix = nodes_matrix
+        self.connections = []
+
+    @abstractmethod
+    def create_connections(self) -> None:
+        pass
+
+    def get_connections(self) -> list[Connection]:
+        return self.connections

agentvis-0.1.0/agentvis/core/connection_creation_strategy/context.py

@@ -0,0 +1,15 @@
+from agentvis.core.connection_creation_strategy.base import ConnectionCreationStrategy
+from agentvis.core.models import Connection
+
+class ContextConnectionCreation:
+    def __init__(self):
+        self.strategy = None
+    
+    def set_strategy(self, strategy: ConnectionCreationStrategy) -> None:
+        self.strategy = strategy
+
+    def create_connections(self) -> None:
+        self.strategy.create_connections()
+    
+    def get_connections(self) -> list[Connection]:
+        return self.strategy.get_connections()

agentvis-0.1.0/agentvis/core/connection_creation_strategy/helper.py

@@ -0,0 +1,18 @@
+from difflib import SequenceMatcher
+
+def get_best_match(output_text: str, tool_input: str) -> dict:
+    matcher = SequenceMatcher(None, output_text, tool_input)
+    blocks = matcher.get_matching_blocks()
+    real_blocks = [b for b in blocks if b.size > 0]
+    if not real_blocks:
+        return None
+
+    best_block = max(real_blocks, key=lambda b: b.size)
+    coverage = best_block.size / len(tool_input)
+
+    return {
+        "start": best_block.a,
+        "end": best_block.a + best_block.size,
+        "matched_text": output_text[best_block.a: best_block.a + best_block.size].strip(),
+        "coverage": coverage,
+    }

agentvis-0.1.0/agentvis/core/connection_creation_strategy/strategy_tool_to_tool.py

@@ -0,0 +1,55 @@
+from agentvis.core.connection_creation_strategy.base import ConnectionCreationStrategy
+from agentvis.core.models import Connection, MessageType, Node, ConnectionData, ConnectionType, ToolOutputMatchDetails
+from agentvis.core.retriever_strategy import ContextRetrieverStrategy, BM25RetrieverStrategy
+from agentvis.core.connection_creation_strategy.helper import get_best_match
+
+class StrategyToolToTool(ConnectionCreationStrategy):
+    def __init__(self, nodes_matrix: list[list[Node]]):
+        super().__init__(nodes_matrix)
+        self.context_retriever = ContextRetrieverStrategy()
+
+    def create_connections(self) -> None:
+        tool_outputs = [] # store tuple (node_id, output)
+
+        # iterate over each frame
+        for frame in self.nodes_matrix:
+            for node in frame:
+                if node.type != MessageType.ToolMessage.value:
+                    break
+                tool_args = node.data["tool_args"]
+                for key,value in tool_args.items():
+                    if not tool_outputs:
+                        break
+                    selected_document = self.context_retriever.retrieve(str(value))
+                    if selected_document:
+                        document_index, confidence_score = selected_document.document_index, selected_document.confidence_score
+                        if confidence_score == 0.0:
+                            continue
+                        u,v = tool_outputs[document_index][0],node.id
+                        tool_output_content = tool_outputs[document_index][1]
+                        best_match = get_best_match(tool_output_content, value)
+                        self.connections.append(
+                            Connection(
+                                id=f"{u}-{v}", 
+                                source=u, 
+                                target=v, 
+                                data=ConnectionData(
+                                    connection_type=ConnectionType.ToolToTool, 
+                                    connection_details=ToolOutputMatchDetails(
+                                        target_tool_arg={key:value}, 
+                                        source_tool_output_matched_text=best_match["matched_text"] if best_match else "", 
+                                        source_tool_ouput_start_index=best_match["start"] if best_match else 0, 
+                                        source_tool_ouput_end_index=best_match["end"] if best_match else 0, 
+                                        confidence_score=confidence_score
+                                    )
+                                )
+                            )
+                        )
+            
+            for node in frame:
+                if node.type != MessageType.ToolMessage.value:
+                    break
+                if node.data["content"]:
+                    tool_outputs.append((node.id, node.data["content"]))
+                self.context_retriever.set_strategy(BM25RetrieverStrategy(documents=[str(tool_output) for _,tool_output in tool_outputs]))
+                self.context_retriever.index()

agentvis-0.1.0/agentvis/core/export/__init__.py

@@ -0,0 +1 @@
+from .main import ExportFactory

agentvis-0.1.0/agentvis/core/export/base.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+from agentvis.core.models import AgentGraph
+
+class ExportStrategy(ABC):
+    def __init__(self, graph: AgentGraph):
+        self.graph = graph
+
+    @abstractmethod
+    def export(self) -> str:
+        raise NotImplementedError

agentvis-0.1.0/agentvis/core/export/json.py

@@ -0,0 +1,13 @@
+from agentvis.core.export.base import ExportStrategy
+from agentvis.core.models import AgentGraph
+import json
+
+class JSONExportStrategy(ExportStrategy):
+    def __init__(self, graph: AgentGraph):
+        super().__init__(graph)
+
+    def export(self) -> str:
+        return json.dumps(
+            {"frames": [frame.model_dump() for frame in self.graph.frames], "connections": [connection.model_dump() for connection in self.graph.connections]},
+            separators=(",", ":")
+        )

agentvis-0.1.0/agentvis/core/export/link.py

@@ -0,0 +1,25 @@
+from agentvis.core.export.base import ExportStrategy
+from agentvis.core.models import AgentGraph
+import json
+import zlib
+import base64
+
+class LinkExportStrategy(ExportStrategy):
+    def __init__(self, graph: AgentGraph):
+        super().__init__(graph)
+        self.BASE_URL = "https://agentvis.vercel.app"
+
+    def export(self) -> str:
+        data = {
+            "frames": [frame.model_dump() for frame in self.graph.frames],
+            "connections": [
+                connection.model_dump()
+                for connection in self.graph.connections
+            ],
+        }
+
+        json_string = json.dumps(data, separators=(",", ":"))
+        compressed = zlib.compress(json_string.encode("utf-8"))
+        encoded = base64.urlsafe_b64encode(compressed).decode("utf-8")
+
+        return f"{self.BASE_URL}?view={encoded}"

agentvis-0.1.0/agentvis/core/export/main.py

@@ -0,0 +1,15 @@
+from agentvis.core.models import AgentGraph
+from typing import Literal
+from agentvis.core.export.json import JSONExportStrategy
+from agentvis.core.export.link import LinkExportStrategy
+
+class ExportFactory:
+    @staticmethod
+    def export_graph(graph: AgentGraph, export_strategy: Literal["json", "link"] = "json") -> str:
+        match export_strategy:
+            case "json":
+                return JSONExportStrategy(graph).export()
+            case "link":
+                return LinkExportStrategy(graph).export()
+            case _:
+                raise ValueError(f"Invalid export strategy: {export_strategy}")

agentvis-0.1.0/agentvis/core/main.py

@@ -0,0 +1,51 @@
+from agentvis.core.models import LLMMessage, Frame, Node, MessageType, Connection
+from agentvis.core.connection_creation_strategy import ContextConnectionCreation, StrategyToolToTool
+from collections import defaultdict
+
+class BusinessLogic:
+    @staticmethod
+    def build_frames(messages: list[LLMMessage]) -> list[Frame]:
+        frames = []
+        tool_msg_start_idx, tool_msg_end_idx = -1, -1
+        function_to_args_map = defaultdict(dict)
+        for idx, message in enumerate(messages):
+            # if tool message, store the start and end index of the tool message
+            if message.type == MessageType.ToolMessage.value:
+                if tool_msg_start_idx == -1:
+                    tool_msg_start_idx = idx
+                tool_msg_end_idx = idx
+            else:
+                if tool_msg_start_idx != -1 and tool_msg_end_idx != -1:
+                    tool_nodes = [Node(id=tool_msg.id, type=tool_msg.type, data={"content": tool_msg.content, "tool_name": tool_msg.tool_name, "tool_args": function_to_args_map[tool_msg.tool_call_id][tool_msg.tool_name]}) for tool_msg in messages[tool_msg_start_idx:tool_msg_end_idx+1]]
+                    frames.append(Frame(nodes=tool_nodes))
+                    tool_msg_start_idx, tool_msg_end_idx = -1, -1
+                    function_to_args_map = defaultdict(dict)
+
+                # simply add the frame   
+                frames.append(Frame(
+                    nodes=[Node(
+                        id=message.id,
+                        type=message.type,
+                        data={"content": message.content}
+                    )]
+                ))
+            
+            # if ai message, store the function calls
+            if message.type == MessageType.AIMessage.value:
+                if message.tool_calls:
+                    for tool_call in message.tool_calls:
+                        function_to_args_map[tool_call.tool_call_id] = {tool_call.name: tool_call.args}
+
+        return frames
+    
+    @staticmethod
+    def create_connections(frames: list[Frame]) -> list[Connection]:
+        nodes_matrix = []
+
+        for frame in frames:
+            nodes_matrix.append(frame.nodes)
+
+        context_connection_creation = ContextConnectionCreation()
+        context_connection_creation.set_strategy(StrategyToolToTool(nodes_matrix))
+        context_connection_creation.create_connections()
+        return context_connection_creation.get_connections()

agentvis-0.1.0/agentvis/core/models.py

@@ -0,0 +1,55 @@
+from enum import Enum
+from pydantic import BaseModel
+
+# models for tree structure
+class MessageType(str, Enum):
+    AIMessage = "AIMessage"
+    ToolMessage = "ToolMessage"
+    HumanMessage = "HumanMessage"
+    SystemMessage = "SystemMessage"
+
+class Node(BaseModel):
+    id: str
+    type: MessageType
+    data: dict = {}
+
+class ConnectionType(str, Enum):
+    ToolToTool = "ToolToTool"
+
+class ToolOutputMatchDetails(BaseModel):
+    target_tool_arg: dict = {}
+    source_tool_output_matched_text: str = ""
+    source_tool_ouput_start_index: int = 0
+    source_tool_ouput_end_index: int = 0
+    confidence_score: float = 0.0
+
+class ConnectionData(BaseModel):
+    connection_type: ConnectionType
+    connection_details: ToolOutputMatchDetails = None
+
+class Connection(BaseModel):
+    id: str
+    source: str
+    target: str
+    data: ConnectionData = None
+
+class Frame(BaseModel):
+    nodes: list[Node]
+
+class AgentGraph(BaseModel):
+    frames: list[Frame]
+    connections: list[Connection]
+
+# models for LLM messages
+class ToolCall(BaseModel):
+    name: str
+    args: dict
+    tool_call_id: str
+
+class LLMMessage(BaseModel):
+    id: str
+    type: MessageType
+    content: str = ""
+    tool_calls: list[ToolCall] = []
+    tool_name: str = ""
+    tool_call_id: str = ""

agentvis-0.1.0/agentvis/core/retriever_strategy/__init__.py

@@ -0,0 +1,2 @@
+from .context import ContextRetrieverStrategy
+from .bm25 import BM25RetrieverStrategy

agentvis-0.1.0/agentvis/core/retriever_strategy/base.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from agentvis.core.retriever_strategy.models import SelectedDocument
+
+class RetrieverStrategy(ABC):
+    def __init__(self, documents: list[str]):
+        self.documents = documents
+        self.retriever = None
+
+    @abstractmethod
+    def index(self):
+        pass
+
+    @abstractmethod
+    def retrieve(self, query: str, k: int = 1) -> SelectedDocument:
+        pass

agentvis-0.1.0/agentvis/core/retriever_strategy/bm25.py

@@ -0,0 +1,24 @@
+import bm25s
+from agentvis.core.retriever_strategy.base import RetrieverStrategy
+from agentvis.core.retriever_strategy.models import SelectedDocument
+
+class BM25RetrieverStrategy(RetrieverStrategy):
+    def __init__(self, documents: list[str]):
+        super().__init__(documents)
+    
+    def tokenize(self, text: str) -> list[str]:
+        return text.lower().strip().split()
+
+    def index(self):
+        self.retriever = bm25s.BM25()
+        tokenized_corpus = [self.tokenize(doc) for doc in self.documents]
+        self.retriever.index(tokenized_corpus)
+
+    def retrieve(self, query: str, k: int = 1) -> SelectedDocument:
+        try:
+            return SelectedDocument(
+                document_index=int(self.retriever.retrieve([self.tokenize(query)], k=k).documents[0][0]),
+                confidence_score=float(self.retriever.retrieve([self.tokenize(query)], k=k).scores[0][0])
+            )
+        except IndexError:
+            return None

agentvis-0.1.0/agentvis/core/retriever_strategy/context.py

@@ -0,0 +1,15 @@
+from agentvis.core.retriever_strategy.base import RetrieverStrategy
+from agentvis.core.retriever_strategy.models import SelectedDocument
+
+class ContextRetrieverStrategy:
+    def __init__(self):
+        self.strategy = None
+
+    def set_strategy(self, strategy: RetrieverStrategy):
+        self.strategy = strategy
+
+    def index(self):
+        self.strategy.index()
+
+    def retrieve(self, query: str, k: int = 1) -> SelectedDocument:
+        return self.strategy.retrieve(query, k)

agentvis-0.1.0/agentvis/core/retriever_strategy/models.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+class SelectedDocument(BaseModel):
+    document_index: int
+    confidence_score: float

agentvis-0.1.0/agentvis/framework/base.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+from agentvis.core.models import AgentGraph
+
+class AIFrameWork(ABC):
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def build_agent_graph(self, messages = []) -> AgentGraph:
+        raise NotImplementedError

agentvis-0.1.0/agentvis/framework/langchain/__init__.py

@@ -0,0 +1 @@
+from .main import LangChainAdapter

agentvis-0.1.0/agentvis/framework/langchain/main.py

@@ -0,0 +1,36 @@
+from agentvis.framework.base import AIFrameWork
+from agentvis.core.models import LLMMessage, Frame, ToolCall, AgentGraph
+from agentvis.core import BusinessLogic
+from langchain.messages import ToolMessage, AIMessage, HumanMessage, SystemMessage
+
+class LangChainAdapter(AIFrameWork):
+    def __init__(self):
+        super().__init__()
+
+    def build_agent_graph(self, messages: list[ToolMessage | AIMessage | HumanMessage | SystemMessage]) -> AgentGraph:
+        _messages: list[LLMMessage] = []
+
+        # convert messages to LLMMessage
+        for message in messages:
+            tool_calls = []
+            tool_name = ""
+            tool_call_id = ""
+
+            if isinstance(message, AIMessage):
+                tool_calls = [ToolCall(name=tool_call["name"], args=tool_call["args"], tool_call_id=tool_call["id"]) for tool_call in message.tool_calls]
+            if isinstance(message, ToolMessage):
+                tool_name = message.name
+                tool_call_id = message.tool_call_id
+                
+            _messages.append(LLMMessage(
+                id=message.id,
+                type=message.__class__.__name__,
+                content=message.content,
+                tool_calls=tool_calls,
+                tool_name=tool_name,
+                tool_call_id=tool_call_id
+            ))
+
+        frames = BusinessLogic.build_frames(_messages)
+        connections = BusinessLogic.create_connections(frames)
+        return AgentGraph(frames=frames, connections=connections)

agentvis-0.1.0/agentvis.egg-info/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: agentvis
+Version: 0.1.0
+Summary: Framework-agnostic reasoning trace visualization tool for AI agents.
+Author: Nitesh Kumar
+License: Apache License 2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: bm25s==0.3.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1.0; extra == "langchain"
+
+# agentvis
+
+<p align="center">
+  <picture align="center">
+    <img align="center" alt="agentvis logo" src="https://raw.githubusercontent.com/kumarniteshpersonal-beep/agentvis/968caea6e04577583d7d16f7015b9925362d5f53/packages/ui/public/agentvis_logo.svg" width="560">
+  </picture>
+</p>
+
+
+*agentvis* visualizes an agent’s reasoning trace, giving you clear insight into *why* the agent chose a particular path or triggered a specific tool call.  
+
+By exposing the influence flow behind each decision, it transforms opaque agent behavior into something understandable and actionable — so you can confidently refine and improve your prompts, which is often the hardest part of building reliable agents. 🧠✨
+
+## *agentvis* reasoning visualization example
+
+![flow_diagram](https://raw.githubusercontent.com/kumarniteshpersonal-beep/agentvis/refs/heads/main/packages/py/images/vis.png)
+
+## Installation
+
+Install core:
+
+```bash
+pip install agentvis
+```
+
+With LangChain support:
+
+```bash
+pip install agentvis[langchain]
+```
+
+
+## How to generate an agent reasoning graph
+
+### 1. Define your LangChain / LangGraph agent
+
+```python
+from langchain_tavily import TavilySearch
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.agents import create_agent
+from langchain.messages import HumanMessage
+import os
+
+os.environ["TAVILY_API_KEY"] = "<your-tavily-api-key>"
+
+tavily_search = TavilySearch(
+    max_results=5,
+    search_depth="basic",
+)
+
+llm = ChatGoogleGenerativeAI(
+    model="gemini-2.5-flash-lite",
+    temperature=0.7,
+    google_api_key="<your-google-api-key>",
+)
+
+agent = create_agent(
+    llm,
+    [tavily_search],
+    system_prompt=(
+        "You are a helpful web search agent. "
+        "Use the Tavily tool when you need fresh information from the web."
+    ),
+)
+
+result = agent.invoke(
+    {"messages": [HumanMessage("Top warm countries and weather of each.")]}
+)
+messages = result["messages"]
+```
+
+### 2. Build the reasoning graph with *agentvis* and get a shareable link in exchange of messages produced by agent
+
+```python
+from agentvis.framework.langchain import LangChainAdapter
+from agentvis.core.export import ExportFactory
+
+# Convert LLM messages into an AgentGraph
+graph = LangChainAdapter().build_agent_graph(messages)
+
+# Export as a short link you can open in the UI
+link = ExportFactory.export_graph(graph=graph, export_strategy="link")  # or "json"
+print(link)
+```
+
+> Open the printed `link` in your browser to inspect the full reasoning trace of the `websearch` agent. 
+
+## License
+
+This project is licensed under the Apache License 2.0.

agentvis-0.1.0/agentvis.egg-info/SOURCES.txt

@@ -0,0 +1,30 @@
+README.md
+pyproject.toml
+agentvis/__init__.py
+agentvis.egg-info/PKG-INFO
+agentvis.egg-info/SOURCES.txt
+agentvis.egg-info/dependency_links.txt
+agentvis.egg-info/requires.txt
+agentvis.egg-info/top_level.txt
+agentvis/core/__init__.py
+agentvis/core/main.py
+agentvis/core/models.py
+agentvis/core/connection_creation_strategy/__init__.py
+agentvis/core/connection_creation_strategy/base.py
+agentvis/core/connection_creation_strategy/context.py
+agentvis/core/connection_creation_strategy/helper.py
+agentvis/core/connection_creation_strategy/strategy_tool_to_tool.py
+agentvis/core/export/__init__.py
+agentvis/core/export/base.py
+agentvis/core/export/json.py
+agentvis/core/export/link.py
+agentvis/core/export/main.py
+agentvis/core/retriever_strategy/__init__.py
+agentvis/core/retriever_strategy/base.py
+agentvis/core/retriever_strategy/bm25.py
+agentvis/core/retriever_strategy/context.py
+agentvis/core/retriever_strategy/models.py
+agentvis/framework/__init__.py
+agentvis/framework/base.py
+agentvis/framework/langchain/__init__.py
+agentvis/framework/langchain/main.py

agentvis-0.1.0/agentvis.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentvis-0.1.0/agentvis.egg-info/requires.txt

@@ -0,0 +1,5 @@
+bm25s==0.3.0
+pydantic>=2.0.0
+
+[langchain]
+langchain>=0.1.0

agentvis-0.1.0/agentvis.egg-info/top_level.txt

@@ -0,0 +1 @@
+agentvis

agentvis-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "agentvis"
+version = "0.1.0"
+description = "Framework-agnostic reasoning trace visualization tool for AI agents."
+readme = "README.md"
+license = { text = "Apache License 2.0" }
+requires-python = ">=3.9"
+
+authors = [
+  { name = "Nitesh Kumar" }
+]
+
+dependencies = [
+  "bm25s==0.3.0",
+  "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+langchain = ["langchain>=0.1.0"]
+
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["agentvis*"]

agentvis-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+