feat: add Anthropic/Claude support and make agent provider-agnostic

- added langchain-anthropic as optional dependency
- replaced manual openai-specific agent construction with create_tool_calling_agent
  which works with any provider that supports tool calling (openai, anthropic, ollama, etc)
- removed the format_to_openai_tool_messages and OpenAIToolsAgentOutputParser
  imports since they're no longer needed
- updated turtle_agent llm.py to support switching between openai, anthropic
  and ollama via LLM_PROVIDER env var
- updated .env example with anthropic and ollama config options
- ChatAnthropic import is optional so existing installs without
  langchain-anthropic wont break

this came up because a few people asked about claude support (see #56)
and the fix was pretty straightforward since langchain already has the
abstractions for it

Author: dcpagotto

.env

@@ -1,4 +1,16 @@
+# LLM Provider: "openai" (default), "anthropic", or "ollama"
+LLM_PROVIDER=openai
+
 # OpenAI Configuration
 OPENAI_API_KEY=
 OPENAI_API_VERSION=
-OPENAI_API_TYPE=
+OPENAI_API_TYPE=
+OPENAI_MODEL=gpt-4o
+
+# Anthropic Configuration
+ANTHROPIC_API_KEY=
+ANTHROPIC_MODEL=claude-sonnet-4-20250514
+
+# Ollama Configuration (local models)
+OLLAMA_MODEL=llama3
+OLLAMA_BASE_URL=http://localhost:11434

pyproject.toml

@@ -30,6 +30,7 @@ dependencies = [
     "langchain-core~=0.3.52",
     "langchain-openai~=0.3.14",
     "langchain-ollama~=0.3.2",
+    "langchain-anthropic~=0.3.12",
     "pydantic",
     "pyinputplus",
     "azure-identity",

src/rosa/rosa.py

@@ -14,22 +14,25 @@
 
 from typing import Any, AsyncIterable, Dict, Literal, Optional, Union
 
-from langchain.agents import AgentExecutor
-from langchain.agents.format_scratchpad.openai_tools import (
-    format_to_openai_tool_messages,
-)
-from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser
+from langchain.agents import AgentExecutor, create_tool_calling_agent
 from langchain.prompts import MessagesPlaceholder
 from langchain_community.callbacks import get_openai_callback
 from langchain_core.messages import AIMessage, HumanMessage
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_ollama import ChatOllama
 from langchain_openai import AzureChatOpenAI, ChatOpenAI
 
+try:
+    from langchain_anthropic import ChatAnthropic
+except ImportError:
+    ChatAnthropic = None
+
 from .prompts import RobotSystemPrompts, system_prompts
 from .tools import ROSATools
 
 ChatModel = Union[ChatOpenAI, AzureChatOpenAI, ChatOllama]
+if ChatAnthropic is not None:
+    ChatModel = Union[ChatOpenAI, AzureChatOpenAI, ChatOllama, ChatAnthropic]
 
 
 class ROSA:
@@ -38,7 +41,8 @@ class ROSA:
 
     Args:
         ros_version (Literal[1, 2]): The version of ROS that the agent will interact with.
-        llm (Union[AzureChatOpenAI, ChatOpenAI, ChatOllama]): The language model to use for generating responses.
+        llm (ChatModel): The language model to use for generating responses. Supports OpenAI, Azure OpenAI,
+            Ollama and Anthropic (Claude) models.
         tools (Optional[list]): A list of additional LangChain tool functions to use with the agent.
         tool_packages (Optional[list]): A list of Python packages containing LangChain tool functions to use.
         prompts (Optional[RobotSystemPrompts]): Custom prompts to use with the agent.
@@ -95,7 +99,6 @@ def __init__(
             ros_version, packages=tool_packages, tools=tools, blacklist=self.__blacklist
         )
         self.__prompts = self._get_prompts(prompts)
-        self.__llm_with_tools = self.__llm.bind_tools(self.__tools.get_tools())
         self.__agent = self._get_agent()
         self.__executor = self._get_executor(verbose=verbose)
         self.__show_token_usage = show_token_usage if not streaming else False
@@ -245,18 +248,15 @@ def _get_executor(self, verbose: bool) -> AgentExecutor:
         return executor
 
     def _get_agent(self):
-        """Create and return an agent for processing user inputs and generating responses."""
-        agent = (
-            {
-                "input": lambda x: x["input"],
-                "agent_scratchpad": lambda x: format_to_openai_tool_messages(
-                    x["intermediate_steps"]
-                ),
-                "chat_history": lambda x: x["chat_history"],
-            }
-            | self.__prompts
-            | self.__llm_with_tools
-            | OpenAIToolsAgentOutputParser()
+        """Create and return an agent for processing user inputs and generating responses.
+
+        Uses create_tool_calling_agent which is provider-agnostic and works with
+        any LLM that supports tool calling (OpenAI, Anthropic, Ollama, etc).
+        """
+        agent = create_tool_calling_agent(
+            llm=self.__llm,
+            tools=self.__tools.get_tools(),
+            prompt=self.__prompts,
         )
         return agent
 

src/turtle_agent/scripts/llm.py

@@ -19,14 +19,43 @@
 
 
 def get_llm(streaming: bool = False):
-    """A helper function to get the LLM instance."""
+    """A helper function to get the LLM instance.
+
+    Supports OpenAI (default), Anthropic and Ollama models.
+    Set the LLM_PROVIDER env variable to switch between providers:
+      - "openai" (default): uses OPENAI_API_KEY
+      - "anthropic": uses ANTHROPIC_API_KEY
+      - "ollama": uses local Ollama instance
+    """
     dotenv.load_dotenv(dotenv.find_dotenv())
 
-    llm = ChatOpenAI(
-        api_key=get_env_variable("OPENAI_API_KEY"),
-        model="gpt-5.1",
-        streaming=streaming,
-    )
+    provider = os.getenv("LLM_PROVIDER", "openai").lower()
+
+    if provider == "anthropic":
+        try:
+            from langchain_anthropic import ChatAnthropic
+        except ImportError:
+            raise ImportError(
+                "langchain-anthropic is required for Anthropic support. "
+                "Install it with: pip install langchain-anthropic"
+            )
+        llm = ChatAnthropic(
+            api_key=get_env_variable("ANTHROPIC_API_KEY"),
+            model=os.getenv("ANTHROPIC_MODEL", "claude-sonnet-4-20250514"),
+            streaming=streaming,
+        )
+    elif provider == "ollama":
+        from langchain_ollama import ChatOllama
+        llm = ChatOllama(
+            model=os.getenv("OLLAMA_MODEL", "llama3"),
+            base_url=os.getenv("OLLAMA_BASE_URL", "http://localhost:11434"),
+        )
+    else:
+        llm = ChatOpenAI(
+            api_key=get_env_variable("OPENAI_API_KEY"),
+            model=os.getenv("OPENAI_MODEL", "gpt-4o"),
+            streaming=streaming,
+        )
 
     return llm