langgraph-agent-toolkit 0.1.0__py3-none-any.whl

langgraph_agent_toolkit/helper/constants.py

@@ -0,0 +1,10 @@
+DEFAULT_AGENT = "react-agent"
+DEFAULT_MAX_MESSAGE_HISTORY_LENGTH = 6 + 1  # N messages + 1 system message
+DEFAULT_RECURSION_LIMIT = 25
+DEFAULT_OPENAI_COMPATIBLE_MODEL_PARAMS = dict(
+    temperature=0.0,
+    max_tokens=1024,
+    top_p=0.7,
+    streaming=True,
+)
+DEFAULT_CACHE_TTL_SECOND = 60 * 10  # 10 minutes

langgraph_agent_toolkit/helper/logging.py

@@ -0,0 +1,111 @@
+import logging
+import os
+import sys
+from typing import Any, Dict, Optional
+
+from loguru import logger as loguru_logger
+
+from langgraph_agent_toolkit.helper.types import EnvironmentMode
+
+
+class SingletonMeta(type):
+    """Singleton metaclass to ensure only one instance of LoggerConfig exists."""
+
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            instance = super().__call__(*args, **kwargs)
+            cls._instances[cls] = instance
+        return cls._instances[cls]
+
+
+class LoggerConfig(metaclass=SingletonMeta):
+    """Singleton class for configuring and managing the logger."""
+
+    def __init__(self):
+        self.env = EnvironmentMode(os.environ.get("ENV_MODE", EnvironmentMode.PRODUCTION))
+        self.log_level = os.environ.get("LOG_LEVEL", "INFO" if self.env == EnvironmentMode.PRODUCTION else "DEBUG")
+        self.json_logs = os.environ.get("JSON_LOGS", "false").lower() == "true"
+        self.colorize = os.environ.get("COLORIZE", "true").lower() == "true"
+
+        # Configure logger on initialization
+        self._setup_logger()
+
+    def _format_record(self, record: Dict[str, Any]) -> str:
+        """Format log records for human-readable output (text mode only)."""
+        # This formatter is only used when NOT in JSON mode
+        return (
+            "<green>[{level}]</green> <blue>{time:YYYY-MM-DD HH:mm:ss.SS}</blue>"
+            " | <cyan>{module}:{function}:{line}</cyan>"
+            " | <white>{message}</white>\n"
+        )
+
+    def _setup_logger(self) -> None:
+        """Configure Loguru logger based on environment settings."""
+        # Remove default handlers
+        try:
+            loguru_logger.remove(0)
+        except Exception:
+            pass
+
+        # Configure stderr handler with the correct settings for JSON or text mode
+        if self.json_logs:
+            # For JSON output, don't provide a formatter function - let Loguru handle serialization
+            loguru_logger.add(
+                sys.stderr,
+                level=self.log_level,
+                format=self._format_record,  # No custom formatter for JSON mode
+                serialize=True,  # Enable JSON serialization
+                colorize=False,  # No color in JSON mode
+                enqueue=True,
+                backtrace=True,
+                diagnose=True,
+            )
+        else:
+            # For text output, use the formatter function
+            loguru_logger.add(
+                sys.stderr,
+                level=self.log_level,
+                format=self._format_record,
+                serialize=False,  # Disable JSON serialization
+                colorize=self.colorize,
+                enqueue=True,
+                backtrace=True,
+                diagnose=True,
+            )
+
+        # Log startup configuration
+        loguru_logger.debug(
+            "Logger initialized",
+            extra={
+                "environment": self.env,
+                "log_level": self.log_level,
+                "json_logs": self.json_logs,
+                "colorize": self.colorize,
+            },
+        )
+
+    @property
+    def logger(self):
+        """Get the configured logger instance."""
+        return loguru_logger
+
+
+class InterceptHandler(logging.Handler):
+    """Redirect FastAPI's built-in logger to Loguru."""
+
+    def emit(self, record: Optional[logging.LogRecord]) -> None:
+        if record is None:
+            return
+
+        loguru_level = record.levelname.upper()
+        if record.exc_info is not None:
+            logger.opt(exception=record.exc_info).log(loguru_level, record.getMessage())
+        else:
+            logger.log(loguru_level, record.getMessage())
+
+
+# Initialize singleton and expose logger
+_logger_config = LoggerConfig()
+logger = _logger_config.logger

langgraph_agent_toolkit/helper/types.py

@@ -0,0 +1,7 @@
+from enum import StrEnum, auto
+
+
+class EnvironmentMode(StrEnum):
+    PRODUCTION = auto()
+    STAGING = auto()
+    DEVELOPMENT = auto()

langgraph_agent_toolkit/helper/utils.py

@@ -0,0 +1,80 @@
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    ToolMessage,
+)
+from langchain_core.messages import (
+    ChatMessage as LangchainChatMessage,
+)
+from pydantic import HttpUrl, TypeAdapter
+
+from langgraph_agent_toolkit.schema import ChatMessage
+
+
+def check_str_is_http(x: str) -> str:
+    http_url_adapter = TypeAdapter(HttpUrl)
+    return str(http_url_adapter.validate_python(x))
+
+
+def convert_message_content_to_string(content: str | list[str | dict]) -> str:
+    if isinstance(content, str):
+        return content
+    text: list[str] = []
+    for content_item in content:
+        if isinstance(content_item, str):
+            text.append(content_item)
+            continue
+        if content_item["type"] == "text":
+            text.append(content_item["text"])
+    return "".join(text)
+
+
+def langchain_to_chat_message(message: BaseMessage) -> ChatMessage:
+    """Create a ChatMessage from a LangChain message."""
+    match message:
+        case HumanMessage():
+            human_message = ChatMessage(
+                type="human",
+                content=convert_message_content_to_string(message.content),
+            )
+            return human_message
+        case AIMessage():
+            ai_message = ChatMessage(
+                type="ai",
+                content=convert_message_content_to_string(message.content),
+            )
+            if message.tool_calls:
+                ai_message.tool_calls = message.tool_calls
+            if message.response_metadata:
+                ai_message.response_metadata = message.response_metadata
+            return ai_message
+        case ToolMessage():
+            tool_message = ChatMessage(
+                type="tool",
+                content=convert_message_content_to_string(message.content),
+                tool_call_id=message.tool_call_id,
+            )
+            return tool_message
+        case LangchainChatMessage():
+            if message.role == "custom":
+                custom_message = ChatMessage(
+                    type="custom",
+                    content="",
+                    custom_data=message.content[0],
+                )
+                return custom_message
+            else:
+                raise ValueError(f"Unsupported chat message role: {message.role}")
+        case _:
+            raise ValueError(f"Unsupported message type: {message.__class__.__name__}")
+
+
+def remove_tool_calls(content: str | list[str | dict]) -> str | list[str | dict]:
+    """Remove tool calls from content."""
+    if isinstance(content, str):
+        return content
+    # Currently only Anthropic models stream tool calls, using content item type tool_use.
+    return [
+        content_item for content_item in content if isinstance(content_item, str) or content_item["type"] != "tool_use"
+    ]

langgraph_agent_toolkit/run_agent.py

@@ -0,0 +1,68 @@
+import asyncio
+import random
+from uuid import UUID
+
+from dotenv import find_dotenv, load_dotenv
+from langchain_core.runnables import RunnableConfig
+from langfuse.callback import CallbackHandler
+
+
+load_dotenv(find_dotenv())
+
+from langgraph_agent_toolkit.agents.agent_executor import AgentExecutor
+from langgraph_agent_toolkit.core.settings import settings
+from langgraph_agent_toolkit.helper.constants import DEFAULT_AGENT
+from langgraph_agent_toolkit.helper.logging import logger
+
+
+# agent = AgentExecutor(*settings.AGENT_PATHS).get_agent("react-agent").graph
+# agent = AgentExecutor(*settings.AGENT_PATHS).get_agent("react-agent-so").graph
+agent = AgentExecutor(*settings.AGENT_PATHS).get_agent(DEFAULT_AGENT).graph
+
+
+async def main() -> None:
+    inputs = {
+        "messages": [("user", "Find me a recipe for chocolate chip cookies and how Dynamo Kyiv played last game")]
+    }
+
+    rd = random.Random()
+    rd.seed(0)
+    thread_id = UUID(int=rd.getrandbits(128), version=4)
+
+    logger.info(f"Starting agent with thread {thread_id}")
+    handler = CallbackHandler(session_id=str(thread_id))
+
+    result = await agent.ainvoke(
+        inputs,
+        config=RunnableConfig(
+            configurable={
+                "thread_id": thread_id,
+                "agent_temperature": 0.9,
+                "agent_top_p": 0.75,
+                "agent_max_tokens": 512,
+                "memory_saver_params": {"k": 3},
+            },
+            callbacks=[handler],
+            recursion_limit=15,
+        ),
+    )
+    logger.info(result.keys())
+    logger.info(result)
+
+    try:
+        result["messages"][-1].pretty_print()
+    except Exception as _:
+        logger.warning("Can't print pretty following message.")
+
+    # Draw the agent graph as png
+    # requires:
+    # brew install graphviz
+    # export CFLAGS="-I $(brew --prefix graphviz)/include"
+    # export LDFLAGS="-L $(brew --prefix graphviz)/lib"
+    # pip install pygraphviz
+    #
+    # agent.get_graph().draw_png("agent_diagram.png")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

langgraph_agent_toolkit/run_client.py

@@ -0,0 +1,55 @@
+import asyncio
+
+from langgraph_agent_toolkit.client import AgentClient
+from langgraph_agent_toolkit.core import settings
+from langgraph_agent_toolkit.schema import ChatMessage
+
+
+async def amain() -> None:
+    client = AgentClient(settings.BASE_URL)
+
+    print("Agent info:")
+    print(client.info)
+
+    print("Chat example:")
+    response = await client.ainvoke("Tell me a brief joke?", model="gpt-4o")
+    response.pretty_print()
+
+    print("\nStream example:")
+    async for message in client.astream("Share a quick fun fact?"):
+        if isinstance(message, str):
+            print(message, flush=True, end="")
+        elif isinstance(message, ChatMessage):
+            print("\n", flush=True)
+            message.pretty_print()
+        else:
+            print(f"ERROR: Unknown type - {type(message)}")
+
+
+def main() -> None:
+    client = AgentClient(settings.BASE_URL)
+
+    print("Agent info:")
+    print(client.info)
+
+    print("Chat example:")
+    response = client.invoke("Tell me a brief joke?", model="gpt-4o")
+    response.pretty_print()
+
+    print("\nStream example:")
+    for message in client.stream("Share a quick fun fact?"):
+        if isinstance(message, str):
+            print(message, flush=True, end="")
+        elif isinstance(message, ChatMessage):
+            print("\n", flush=True)
+            message.pretty_print()
+        else:
+            print(f"ERROR: Unknown type - {type(message)}")
+
+
+if __name__ == "__main__":
+    print("Running in sync mode")
+    main()
+    print("\n\n\n\n\n")
+    print("Running in async mode")
+    asyncio.run(amain())

langgraph_agent_toolkit/run_service.py

@@ -0,0 +1,19 @@
+from dotenv import load_dotenv
+
+from langgraph_agent_toolkit.service.factory import RunnerType, ServiceRunner
+
+
+load_dotenv()
+
+if __name__ == "__main__":
+    # Create and run the service with the ServiceRunner
+    service = ServiceRunner(
+        custom_settings=dict(
+            AGENT_PATHS=[
+                "langgraph_agent_toolkit.agents.blueprints.react.agent:react_agent",
+                "langgraph_agent_toolkit.agents.blueprints.supervisor_agent.agent:supervisor_agent",
+                "langgraph_agent_toolkit.agents.blueprints.chatbot.agent:chatbot_agent",
+            ]
+        ),
+    )
+    handler = service.run(runner_type=RunnerType.UVICORN)

langgraph_agent_toolkit/schema/__init__.py

@@ -0,0 +1,28 @@
+from langgraph_agent_toolkit.schema.models import AllModelEnum
+from langgraph_agent_toolkit.schema.schema import (
+    AgentInfo,
+    ChatHistory,
+    ChatHistoryInput,
+    ChatMessage,
+    Feedback,
+    FeedbackResponse,
+    HealthCheck,
+    ServiceMetadata,
+    StreamInput,
+    UserInput,
+)
+
+
+__all__ = [
+    "AgentInfo",
+    "AllModelEnum",
+    "UserInput",
+    "ChatMessage",
+    "ServiceMetadata",
+    "StreamInput",
+    "Feedback",
+    "FeedbackResponse",
+    "ChatHistoryInput",
+    "ChatHistory",
+    "HealthCheck",
+]

langgraph_agent_toolkit/schema/models.py

@@ -0,0 +1,25 @@
+from enum import StrEnum, auto
+from typing import TypeAlias
+
+
+class Provider(StrEnum):
+    OPENAI_COMPATIBLE = auto()
+    FAKE = auto()
+
+
+class OpenAICompatibleName(StrEnum):
+    """OpenAI compatible model names.
+
+    https://platform.openai.com/docs/guides/text-generation
+    """
+
+    OPENAI_COMPATIBLE = "openai-compatible"
+
+
+class FakeModelName(StrEnum):
+    """Fake model for testing."""
+
+    FAKE = "fake"
+
+
+AllModelEnum: TypeAlias = OpenAICompatibleName | FakeModelName

langgraph_agent_toolkit/schema/schema.py

@@ -0,0 +1,210 @@
+from typing import Any, Literal, NotRequired
+
+from pydantic import BaseModel, Field, SerializeAsAny
+from typing_extensions import TypedDict
+
+from langgraph_agent_toolkit.helper.constants import (
+    DEFAULT_AGENT,
+    DEFAULT_OPENAI_COMPATIBLE_MODEL_PARAMS,
+    DEFAULT_RECURSION_LIMIT,
+)
+from langgraph_agent_toolkit.schema.models import AllModelEnum, OpenAICompatibleName
+
+
+class AgentInfo(BaseModel):
+    """Info about an available agent."""
+
+    key: str = Field(
+        description="Agent key.",
+        examples=["langgraph-supervisor-agent"],
+    )
+    description: str = Field(
+        description="Description of the agent.",
+        examples=["A research assistant."],
+    )
+
+
+class ServiceMetadata(BaseModel):
+    """Metadata about the service including available agents and models."""
+
+    agents: list[AgentInfo] = Field(
+        description="List of available agents.",
+    )
+    models: list[AllModelEnum] = Field(
+        description="List of available LLMs.",
+    )
+    default_agent: str = Field(
+        description="Default agent used when none is specified.",
+        examples=[DEFAULT_AGENT],
+    )
+    default_model: AllModelEnum = Field(
+        description="Default model used when none is specified.",
+    )
+
+
+class UserInput(BaseModel):
+    """Basic user input for the agent."""
+
+    message: str = Field(
+        description="User input to the agent.",
+        examples=["What is the weather in Tokyo?"],
+    )
+    model: SerializeAsAny[AllModelEnum] | None = Field(
+        title="Model",
+        description="LLM Model to use for the agent.",
+        default=OpenAICompatibleName.OPENAI_COMPATIBLE,
+        examples=[OpenAICompatibleName.OPENAI_COMPATIBLE],
+    )
+    thread_id: str | None = Field(
+        description="Thread ID to persist and continue a multi-turn conversation.",
+        default=None,
+        examples=["847c6285-8fc9-4560-a83f-4e6285809254"],
+    )
+    agent_config: dict[str, Any] = Field(
+        description="Additional configuration to pass through to the agent",
+        default={},
+        examples=[
+            {
+                "memory_saver_params": {"k": 6},
+                **DEFAULT_OPENAI_COMPATIBLE_MODEL_PARAMS,
+            },
+        ],
+    )
+    recursion_limit: int | None = Field(
+        description="Recursion limit for the agent.",
+        default=None,  # Changed from DEFAULT_RECURSION_LIMIT to None
+        examples=[DEFAULT_RECURSION_LIMIT],
+    )
+
+
+class StreamInput(UserInput):
+    """User input for streaming the agent's response."""
+
+    stream_tokens: bool = Field(
+        description="Whether to stream LLM tokens to the client.",
+        default=True,
+    )
+
+
+class ToolCall(TypedDict):
+    """Represents a request to call a tool."""
+
+    name: str
+    """The name of the tool to be called."""
+    args: dict[str, Any]
+    """The arguments to the tool call."""
+    id: str | None
+    """An identifier associated with the tool call."""
+    type: NotRequired[Literal["tool_call"]]
+
+
+class ChatMessage(BaseModel):
+    """Message in a chat."""
+
+    type: Literal["human", "ai", "tool", "custom"] = Field(
+        description="Role of the message.",
+        examples=["human", "ai", "tool", "custom"],
+    )
+    content: str = Field(
+        description="Content of the message.",
+        examples=["Hello, world!"],
+    )
+    tool_calls: list[ToolCall] = Field(
+        description="Tool calls in the message.",
+        default=[],
+    )
+    tool_call_id: str | None = Field(
+        description="Tool call that this message is responding to.",
+        default=None,
+        examples=["call_Jja7J89XsjrOLA5r!MEOW!SL"],
+    )
+    run_id: str | None = Field(
+        description="Run ID of the message.",
+        default=None,
+        examples=["847c6285-8fc9-4560-a83f-4e6285809254"],
+    )
+    response_metadata: dict[str, Any] = Field(
+        description="Response metadata. For example: response headers, logprobs, token counts.",
+        default={},
+    )
+    custom_data: dict[str, Any] = Field(
+        description="Custom message data.",
+        default={},
+    )
+
+    def pretty_repr(self) -> str:
+        """Get a pretty representation of the message."""
+        base_title = self.type.title() + " Message"
+        padded = " " + base_title + " "
+        sep_len = (80 - len(padded)) // 2
+        sep = "=" * sep_len
+        second_sep = sep + "=" if len(padded) % 2 else sep
+        title = f"{sep}{padded}{second_sep}"
+        return f"{title}\n\n{self.content}"
+
+    def pretty_print(self) -> None:
+        print(self.pretty_repr())  # noqa: T201
+
+
+class Feedback(BaseModel):
+    """Feedback for a run, to record to LangSmith."""
+
+    run_id: str = Field(
+        description="Run ID to record feedback for.",
+        examples=["847c6285-8fc9-4560-a83f-4e6285809254"],
+    )
+    key: str = Field(
+        description="Feedback key.",
+        examples=["human-feedback-stars"],
+    )
+    score: float = Field(
+        description="Feedback score.",
+        examples=[0.8],
+    )
+    kwargs: dict[str, Any] = Field(
+        description="Additional feedback kwargs, passed to LangSmith.",
+        default={},
+        examples=[{"comment": "In-line human feedback"}],
+    )
+
+
+class FeedbackResponse(BaseModel):
+    """Response after recording feedback."""
+
+    status: Literal["success"] = "success"
+    run_id: str = Field(
+        description="Run ID for which feedback was recorded.",
+        examples=["847c6285-8fc9-4560-a83f-4e6285809254"],
+    )
+    message: str = Field(
+        description="Descriptive message about the feedback operation.",
+        default="Feedback recorded successfully.",
+    )
+
+
+class ChatHistoryInput(BaseModel):
+    """Input for retrieving chat history."""
+
+    thread_id: str = Field(
+        description="Thread ID to persist and continue a multi-turn conversation.",
+        examples=["847c6285-8fc9-4560-a83f-4e6285809254"],
+    )
+
+
+class ChatHistory(BaseModel):
+    messages: list[ChatMessage]
+
+
+class HealthCheck(BaseModel):
+    """Response model to validate and return when performing a health check."""
+
+    content: str = Field(
+        ...,
+        description="Health status of the service.",
+        examples=["healthy"],
+    )
+    version: str = Field(
+        ...,
+        description="Version of the service.",
+        examples=["1.0.0"],
+    )

langgraph_agent_toolkit/schema/task_data.py

@@ -0,0 +1,72 @@
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class TaskData(BaseModel):
+    name: str | None = Field(description="Name of the task.", default=None, examples=["Check input safety"])
+    run_id: str = Field(
+        description="ID of the task run to pair state updates to.",
+        default="",
+        examples=["847c6285-8fc9-4560-a83f-4e6285809254"],
+    )
+    state: Literal["new", "running", "complete"] | None = Field(
+        description="Current state of given task instance.",
+        default=None,
+        examples=["running"],
+    )
+    result: Literal["success", "error"] | None = Field(
+        description="Result of given task instance.",
+        default=None,
+        examples=["running"],
+    )
+    data: dict[str, Any] = Field(
+        description="Additional data generated by the task.",
+        default={},
+    )
+
+    def completed(self) -> bool:
+        return self.state == "complete"
+
+    def completed_with_error(self) -> bool:
+        return self.state == "complete" and self.result == "error"
+
+
+class TaskDataStatus:
+    def __init__(self) -> None:
+        import streamlit as st
+
+        self.status = st.status("")
+        self.current_task_data: dict[str, TaskData] = {}
+
+    def add_and_draw_task_data(self, task_data: TaskData) -> None:
+        status = self.status
+        status_str = f"Task **{task_data.name}** "
+        match task_data.state:
+            case "new":
+                status_str += "has :blue[started]. Input:"
+            case "running":
+                status_str += "wrote:"
+            case "complete":
+                if task_data.result == "success":
+                    status_str += ":green[completed successfully]. Output:"
+                else:
+                    status_str += ":red[ended with error]. Output:"
+        status.write(status_str)
+        status.write(task_data.data)
+        status.write("---")
+        if task_data.run_id not in self.current_task_data:
+            # Status label always shows the last newly started task
+            status.update(label=f"""Task: {task_data.name}""")
+        self.current_task_data[task_data.run_id] = task_data
+        if all(entry.completed() for entry in self.current_task_data.values()):
+            # Status is "error" if any task has errored
+            if any(entry.completed_with_error() for entry in self.current_task_data.values()):
+                state = "error"
+            # Status is "complete" if all tasks have completed successfully
+            else:
+                state = "complete"
+        # Status is "running" until all tasks have completed
+        else:
+            state = "running"
+        status.update(state=state)