How to Integrate wigolo with Popular AI Agent Frameworks: LangChain, CrewAI, and LlamaIndex

You can integrate wigolo with LangChain, CrewAI, and LlamaIndex using official wrapper packages that expose wigolo's ten web-intelligence tools as native framework abstractions, enabling zero-cost, privacy-preserving web operations without API keys.

wigolo is a local-first web-intelligence server that provides keyless access to web data through MCP, REST API, and SDK interfaces. When you integrate wigolo with popular AI agent frameworks like LangChain, CrewAI, and LlamaIndex, you replace external API-dependent tools with on-device ML-powered alternatives that guarantee zero cost per query and complete data privacy.

Three Integration Surfaces

wigolo exposes its capabilities through three complementary surfaces that wrapper packages consume:

• MCP (Model Context Protocol): A JSON-RPC channel over stdio, ideal for coding agents like Claude Code and Cursor that already speak MCP.
• REST API: Plain JSON endpoints on localhost:3333 that work with any language or HTTP client.
• SDKs: Thin TypeScript and Python clients (wigolo-sdk) that provide a "local-mode" auto-starting daemon when needed.

Framework-Specific Wrapper Packages

Official wrapper packages transform wigolo's ten tools—search, fetch, crawl, extract, cache, find_similar, research, agent, diff, and watch—into native abstractions for each framework.

LangChain Integration (wigolo-langchain)

The wigolo-langchain package exposes each wigolo tool as a BaseTool and supplies a BaseRetriever wrapping the search and find_similar tools for Retrieval-Augmented Generation (RAG).

According to the KnockOutEZ/wigolo source code, the implementation resides in packages/wigolo-langchain/wigolo_langchain/client.py, where adapters forward calls to the local wigolo client.

CrewAI Integration (wigolo-crewai)

The wigolo-crewai package provides wigolo_tools(), a convenience function returning ready-to-use Tool objects that drop into any crew definition. This lets crews orchestrate wigolo's full toolset without manual configuration.

The source in packages/wigolo-crewai/src/index.ts handles the conversion of wigolo capabilities into CrewAI-compatible Tool instances.

LlamaIndex Integration (wigolo-llamaindex)

The wigolo-llamaindex package implements a BaseReader that converts fetch, crawl, or search results into LlamaIndex Document objects. This makes wigolo a drop-in data source for index-building pipelines.

The implementation lives in packages/wigolo-llamaindex/src/reader.ts, which fetches and crawls pages via the local wigolo daemon and returns properly formatted Document instances.

Core Advantages for Agent Frameworks

All three wrappers inherit wigolo's architectural benefits:

• Zero-key web operations: Search, fetch, crawl, and extract work without external API keys or service accounts.
• On-device ML: Reranking and embeddings run locally, ensuring $0 cost per query and complete privacy.
• Explainable results: Every tool returns evidence, citation IDs, and transparent scoring breakdowns.
• Unified configuration: A single wigolo config file controls behavior across all framework integrations.

Implementation Examples

LangChain Retriever Setup (Python)

Use create_wigolo_retriever from wigolo-langchain to build a RAG pipeline that queries the local daemon:

from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
from wigolo_langchain import create_wigolo_retriever

retriever = create_wigolo_retriever(
    query="latest TypeScript features",
    top_k=5,
)

qa = RetrievalQA.from_chain_type(
    llm=OpenAI(temperature=0),
    chain_type="stuff",
    retriever=retriever,
)

print(qa.run("What new syntax does TypeScript 5.4 introduce?"))

CrewAI Tool Configuration (TypeScript)

Import wigolo_tools from wigolo-crewai to equip crews with web capabilities:

import { Crew, Task } from "crewai";
import { wigolo_tools } from "wigolo-crewai";

const crew = new Crew({
  agents: [{ role: "researcher", goal: "answer web questions" }],
  tasks: [
    new Task({
      name: "Web research",
      instructions: "Find the most recent blog posts about AI agents.",
      tools: wigolo_tools(),
    }),
  ],
});

crew.run();

LlamaIndex Document Loading (Python)

Use WigoloCrawlerReader to crawl sites and build searchable indices using on-device embeddings:

from llama_index import VectorStoreIndex
from wigolo_llamaindex import WigoloCrawlerReader

reader = WigoloCrawlerReader(start_url="https://example.com/docs")
documents = reader.load_data()

index = VectorStoreIndex.from_documents(documents)
response = index.as_query_engine().query(
    "What are the installation steps for wigolo on macOS?"
)
print(response)

Summary

• Install framework-specific packages (wigolo-langchain, wigolo-crewai, wigolo-llamaindex) to integrate wigolo with LangChain, CrewAI, and LlamaIndex.
• Each wrapper maps wigolo's ten tools to native framework abstractions: BaseTool/BaseRetriever for LangChain, Tool objects for CrewAI, and BaseReader for LlamaIndex.
• Source implementations reside in packages/wigolo-langchain/wigolo_langchain/client.py, packages/wigolo-crewai/src/index.ts, and packages/wigolo-llamaindex/src/reader.ts.
• All integrations leverage wigolo's local daemon running on localhost:3333, providing zero-cost, keyless web intelligence with on-device ML.

Frequently Asked Questions

Do I need API keys to use wigolo with these frameworks?

No. According to the KnockOutEZ/wigolo source code, wigolo operates entirely without external API keys for its core web operations including search, fetch, crawl, and extract. The local daemon handles all web intelligence using on-device ML for reranking and embeddings, eliminating per-query costs.

Which wigolo tools are available through each framework wrapper?

All ten wigolo tools—search, fetch, crawl, extract, cache, find_similar, research, agent, diff, and watch—are exposed through each wrapper. The LangChain wrapper implements them as BaseTool instances, CrewAI returns them as Tool objects via wigolo_tools(), and LlamaIndex focuses on document ingestion via fetch, crawl, and search through the BaseReader interface.

How does the local daemon start when using these integrations?

The official SDKs (wigolo-sdk for TypeScript and Python) provide a "local-mode" that automatically starts the wigolo daemon if not already running on localhost:3333. This happens transparently when you initialize the wrapper clients, requiring no manual server management or container orchestration.

Can I use wigolo's MCP interface with these frameworks?

Yes. While the wrapper packages use the REST API and SDKs, wigolo also exposes an MCP (Model Context Protocol) interface via JSON-RPC over stdio. This is defined in the repository's package.json MCP section and is ideal for agents like Claude Code that communicate via MCP rather than direct library imports, complementing the deeper framework integrations.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}