Web Search Plugin

export TAVILY_API_KEY="tvly-xxxxxxxxxxxxx"

# Download from releases
wget https://github.com/nadoo-ai/official-plugins/releases/download/v1.0.0/web-search-1.0.0.nadoo-plugin

# Install to workspace
nadoo-plugin install web-search-1.0.0.nadoo-plugin --workspace your-workspace-id

# Clone repository
git clone https://github.com/nadoo-ai/official-plugins
cd official-plugins

# Build web-search plugin
python build_plugins.py

# Install
nadoo-plugin install dist/web-search-1.0.0.nadoo-plugin --workspace your-workspace-id

{
  "success": true,
  "query": "latest AI news",
  "results": [
    {
      "title": "Article Title",
      "url": "https://example.com/article",
      "content": "Article content snippet...",
      "score": 0.95
    }
  ],
  "answer": "Direct answer to the query (if available)",
  "images": []
}

from nadoo_plugin.api import ToolsClient

tools = ToolsClient(base_url, token, context)

# Simple search
result = tools.invoke(
    tool_name="web-search:search",
    parameters={"query": "latest AI news"}
)

# Access results
for item in result["results"]:
    print(f"{item['title']}: {item['url']}")
    print(f"Relevance: {item['score']}")
    print(f"Content: {item['content'][:200]}...")

# More comprehensive search with advanced depth
result = tools.invoke(
    tool_name="web-search:search",
    parameters={
        "query": "machine learning trends 2024",
        "max_results": 10,
        "search_depth": "advanced"
    }
)

# Advanced search provides:
# - More results
# - Better relevance ranking
# - Deeper analysis

# Search within specific country
result = tools.invoke(
    tool_name="web-search:search",
    parameters={
        "query": "AI companies",
        "country": "south korea",
        "max_results": 5
    }
)

# Get news from specific region
result = tools.invoke(
    tool_name="web-search:search",
    parameters={
        "query": "tech news today",
        "country": "united states"
    }
)

from nadoo_flow import BaseNode, NodeResult, NodeContext, WorkflowContext

class WebSearchNode(BaseNode):
    """Node that searches the web"""

    def __init__(self):
        super().__init__(
            node_id="web_search",
            node_type="search",
            name="WebSearch",
            config={}
        )

    async def execute(
        self,
        node_context: NodeContext,
        workflow_context: WorkflowContext
    ) -> NodeResult:
        # Get query from user input
        query = node_context.input_data.get("query", "")

        if not query:
            return NodeResult(
                success=False,
                error="No search query provided"
            )

        # Search the web
        result = await self.call_tool(
            tool_name="web-search:search",
            parameters={
                "query": query,
                "max_results": 5,
                "search_depth": "basic"
            }
        )

        if result.get("success"):
            return NodeResult(
                success=True,
                output={
                    "query": query,
                    "results": result["results"],
                    "answer": result.get("answer")
                }
            )
        else:
            return NodeResult(
                success=False,
                error=result.get("error", "Search failed")
            )

from nadoo_plugin.api import ToolsClient, LLMClient

class RAGSearchNode(BaseNode):
    """Search web and generate answer with LLM"""

    async def execute(
        self,
        node_context: NodeContext,
        workflow_context: WorkflowContext
    ) -> NodeResult:
        query = node_context.input_data.get("question")

        # Step 1: Search the web
        search_result = await self.call_tool(
            tool_name="web-search:search",
            parameters={
                "query": query,
                "max_results": 5,
                "search_depth": "advanced"
            }
        )

        if not search_result.get("success"):
            return NodeResult(success=False, error="Search failed")

        # Step 2: Build context from search results
        context = "\n\n".join([
            f"[{i+1}] {r['title']}\n{r['content']}"
            for i, r in enumerate(search_result["results"])
        ])

        # Step 3: Generate answer with LLM
        llm_result = await self.call_llm(
            messages=[
                {
                    "role": "system",
                    "content": "Answer based on the provided search results. Include source numbers."
                },
                {
                    "role": "user",
                    "content": f"Question: {query}\n\nSearch Results:\n{context}"
                }
            ]
        )

        return NodeResult(
            success=True,
            output={
                "question": query,
                "answer": llm_result.content,
                "sources": [
                    {"title": r["title"], "url": r["url"]}
                    for r in search_result["results"]
                ]
            }
        )

# Search multiple topics and aggregate
queries = [
    "Python async programming",
    "FastAPI tutorials",
    "LangChain documentation"
]

all_results = []

for query in queries:
    result = tools.invoke(
        tool_name="web-search:search",
        parameters={
            "query": query,
            "max_results": 3
        }
    )

    if result.get("success"):
        all_results.extend(result["results"])

# Now process all_results

result = tools.invoke(
    tool_name="web-search:search",
    parameters={"query": "AI news"}
)

if result.get("success"):
    # Process results
    for item in result["results"]:
        print(item["title"])
else:
    # Handle error
    error = result.get("error", "Unknown error")
    print(f"Search failed: {error}")

    # Common errors:
    # - "TAVILY_API_KEY not set"
    # - "Invalid API key"
    # - "Rate limit exceeded"
    # - "Network error"