mirror of
https://github.com/mcp-use/mcp-use.git
synced 2026-09-14 18:06:01 +08:00
Luigi Pederzani
f08e870e09
* chore: update imports * refactor(mcpagent): update agent creation logic and imports - Replaced `create_tool_calling_agent` with `create_agent` for improved agent instantiation. - Simplified the `_create_agent` method by removing the `AgentExecutor` and directly returning the created agent. - Adjusted type annotations for `_agent_executor` to initialize as `None` instead of using a union type. * feat(mcpagent): migrate to LangChain 1.0.0 and simplify agent methods - Updated MCPAgent to utilize LangChain 1.0.0's `create_agent()` for improved agent instantiation. - Introduced new methods `astream_simplified()` and `run_v2()` that leverage the built-in `astream()` for internal agent loop handling. - Retained legacy methods `stream()` and `run()` for backward compatibility with manual execution. - Enhanced documentation to reflect changes and provide clearer usage examples. * feat(mcpagent): implement dynamic tool updates during agent execution - Enhanced the MCPAgent to support dynamic tool updates when using server_manager mode. - Implemented logic to check for tool changes before and during execution, allowing for immediate updates and safe restarts. - Introduced a maximum restart limit to prevent infinite loops during tool updates. - Updated documentation to reflect the new behavior and usage of dynamic tool management. * refactor(mcpagent): clean up imports and streamline logging - Removed unused imports and organized existing ones for better clarity in `mcpagent.py`. - Simplified logging statements for consistency and improved readability. - Enhanced the overall structure of the code by eliminating unnecessary whitespace. - Updated unit tests to reflect changes in imports and ensure compatibility with the refactored code. * feat(mcpagent): enhance agent execution with step tracking and middleware - Introduced `ModelCallLimitMiddleware` to enforce a maximum number of model calls during agent execution. - Updated the `_consume_and_return` method to return a tuple of the final result and the number of steps taken. - Enhanced telemetry tracking to include steps taken and execution time for better performance insights. - Simplified agent creation logic by integrating middleware directly into the `create_agent` function. - Improved logging for agent execution details, including steps and tool usage. * fix(mcpagent): add null check for node output messages extraction - Updated the MCPAgent to include a null check for `node_output` before attempting to access the "messages" key, preventing potential errors during message extraction. * minor * feat(mcpagent): filter out ToolMessage from history - Updated the MCPAgent to exclude ToolMessage instances from being added to the message history, ensuring that only relevant messages are recorded. - This change helps maintain a cleaner history by avoiding intermediate tool execution details. * fix(mcpagent): set max_steps assignment * ruff * docs * e2e tests for agent * key in tests * fix manager test and split ci tests * telemetry off for tests * fix server manager test * feat(mcpagent): delegate query streaming to remote agent in remote mode - recreated functionality to the MCPAgent to yield results from a remote agent when operating in remote mode, enhancing the agent's capability to handle queries efficiently. * fix: agent unit tests * Print inputs * rollback, wrong repo * fix streaming output * stricter streaming test * pass observability callbacks * fix tests mock --------- Co-authored-by: pietrozullo <pietro.zullo@gmail.com>
85 lines
3.3 KiB
Python
85 lines
3.3 KiB
Python
"""
|
|
End-to-end integration test for agent.stream().
|
|
|
|
Tests the agent.stream() method yielding incremental responses.
|
|
"""
|
|
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
from langchain_core.agents import AgentAction
|
|
from langchain_openai import ChatOpenAI
|
|
|
|
from mcp_use import MCPAgent, MCPClient
|
|
from mcp_use.logging import logger
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.integration
|
|
async def test_agent_stream():
|
|
"""Test agent.stream() yielding incremental responses."""
|
|
server_path = Path(__file__).parent.parent / "servers_for_testing" / "simple_server.py"
|
|
|
|
config = {"mcpServers": {"simple": {"command": sys.executable, "args": [str(server_path), "--transport", "stdio"]}}}
|
|
|
|
client = MCPClient.from_dict(config)
|
|
llm = ChatOpenAI(model="gpt-4o")
|
|
agent = MCPAgent(llm=llm, client=client, max_steps=5)
|
|
|
|
try:
|
|
query = "Add 10 and 20 using the add tool"
|
|
logger.info("\n" + "=" * 80)
|
|
logger.info("TEST: test_agent_stream")
|
|
logger.info("=" * 80)
|
|
logger.info(f"Query: {query}")
|
|
|
|
chunks = []
|
|
intermediate_steps = []
|
|
final_result = None
|
|
|
|
async for chunk in agent.stream(query):
|
|
chunks.append(chunk)
|
|
if isinstance(chunk, tuple):
|
|
action, observation = chunk
|
|
intermediate_steps.append((action, observation))
|
|
logger.info(f"Step {len(intermediate_steps)}:")
|
|
logger.info(f" Tool: {action.tool}")
|
|
logger.info(f" Input: {action.tool_input}")
|
|
logger.info(f" Log: {action.log[:100]}..." if len(action.log) > 100 else f" Log: {action.log}")
|
|
logger.info(f" Observation: {str(observation)[:100]}...")
|
|
elif isinstance(chunk, str):
|
|
final_result = chunk
|
|
logger.info(f"\nFinal result: {chunk}")
|
|
|
|
logger.info(f"\nTotal chunks: {len(chunks)}")
|
|
logger.info(f"Intermediate steps: {len(intermediate_steps)}")
|
|
logger.info(f"Tools used: {agent.tools_used_names}")
|
|
logger.info("=" * 80 + "\n")
|
|
|
|
# Assert we got chunks
|
|
assert len(chunks) > 0, "Should yield at least one chunk"
|
|
|
|
# Assert we got intermediate steps (tool calls)
|
|
assert len(intermediate_steps) > 0, "Should have at least one intermediate step"
|
|
|
|
# Assert intermediate steps have correct structure
|
|
for action, observation in intermediate_steps:
|
|
assert isinstance(action, AgentAction), "Action should be an AgentAction"
|
|
assert hasattr(action, "tool"), "Action should have tool attribute"
|
|
assert hasattr(action, "tool_input"), "Action should have tool_input attribute"
|
|
assert hasattr(action, "log"), "Action should have log attribute"
|
|
assert observation is not None, "Observation should not be None"
|
|
|
|
# Assert final result is a string with expected content
|
|
assert final_result is not None, "Should have a final result"
|
|
assert isinstance(final_result, str), "Final result should be a string"
|
|
assert "30" in final_result, "Final result should contain the answer (30)"
|
|
|
|
# Assert tools were used
|
|
assert len(agent.tools_used_names) > 0, "Should have used at least one tool"
|
|
assert "add" in agent.tools_used_names, "Should have used the 'add' tool"
|
|
|
|
finally:
|
|
await agent.close()
|