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

> Integrate wigolo with LangChain, CrewAI, and LlamaIndex effortlessly. Utilize official wrappers for zero-cost, private web operations with wigolo's AI tools. No API keys needed.

- Repository: [Towhid Khan/wigolo](https://github.com/KnockOutEZ/wigolo)
- Tags: how-to-guide
- Published: 2026-07-29

---

**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`](https://github.com/KnockOutEZ/wigolo/blob/main/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`](https://github.com/KnockOutEZ/wigolo/blob/main/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`](https://github.com/KnockOutEZ/wigolo/blob/main/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:

```python
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:

```typescript
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:

```python
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`](https://github.com/KnockOutEZ/wigolo/blob/main/packages/wigolo-langchain/wigolo_langchain/client.py), [`packages/wigolo-crewai/src/index.ts`](https://github.com/KnockOutEZ/wigolo/blob/main/packages/wigolo-crewai/src/index.ts), and [`packages/wigolo-llamaindex/src/reader.ts`](https://github.com/KnockOutEZ/wigolo/blob/main/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`](https://github.com/KnockOutEZ/wigolo/blob/main/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.