# XavvyNess AI Research Engine (`xavvyness/xavvyness-research-engine`) Actor

Ask any question — get a structured, cited research report in seconds. Live web search + AI synthesis (Groq/Gemini). Returns summary, full report with numbered citations, and source URLs. Quick, Standard, and Deep depth modes. Support email: hello@xavvyness.ai

- **URL**: https://apify.com/xavvyness/xavvyness-research-engine.md
- **Developed by:** [XavvyNess](https://apify.com/xavvyness) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 research reports

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## XavvyNess Research Engine

**AI-powered research agent.** Give it any question or topic — get back a structured, cited research report in seconds. Powered by live web search + smart model routing (Gemini 2.5 Flash / Llama 3.3 70B / Gemini 2.0 Flash).

---

### What it does

Most AI research tools either hallucinate without web access, or dump raw search results with no synthesis. The XavvyNess Research Engine does both:

1. **Searches the live web** via Tavily — real URLs, real content, not stale training data
2. **Synthesizes a structured report** using the best model for the depth you choose
3. **Caches results for 24h** — re-running the same query is instant and free
4. **Returns structured output** — query, summary, full report, sources array, model used, timestamp

---

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `query` | string | *(required)* | What to research. Be specific for better results. |
| `depth` | enum | `standard` | `quick` (3-5 paragraphs) · `standard` (full report) · `deep` (comprehensive, multi-angle) |
| `format` | enum | `markdown` | `markdown` · `bullet` · `json` |
| `includeSource` | boolean | `true` | Include `[n]` citations and source URLs in report |
| `maxResults` | integer | `10` | Number of web sources to pull (3–30) |

#### Example input

```json
{
  "query": "What are the security risks of using LLMs in production APIs?",
  "depth": "deep",
  "format": "markdown",
  "includeSource": true,
  "maxResults": 15
}
````

***

### Example output

Real output from a live run (truncated for display):

```json
{
  "query": "What are the best open source AI coding assistants in 2025?",
  "depth": "standard",
  "format": "markdown",
  "summary": "AI coding assistants have become essential developer tools in 2025. Windsurf, GitHub Copilot, and Cursor lead adoption. Open-source alternatives like Aider and Continue offer strong customization without vendor lock-in. Tabnine and JetBrains AI excel at refactoring and language-specific completions.",
  "report": "### Overview\n\nThe use of Artificial Intelligence (AI) in coding has become increasingly popular in recent years...\n\n### Key Findings\n\n1. **Windsurf**, **GitHub Copilot**, and **Cursor** lead in advanced code generation and IDE integration [1, 2, 3].\n2. **GitHub Copilot** integrates natively with VS Code and Neovim [3, 4].\n3. **Aider** and **Continue** are top open-source alternatives with full local model support [5, 6].\n4. **Tabnine** and **JetBrains AI Assistant** excel at refactoring and language-specific completions [7].\n5. **Gemini** is purpose-built for Android app development [1].\n\n### Sources\n[1] https://... [2] https://...",
  "sources": [
    { "title": "Windsurf", "url": "https://windsurf.com", "snippet": "AI-first code editor..." },
    { "title": "GitHub Copilot", "url": "https://github.com/features/copilot", "snippet": "AI pair programmer..." },
    { "title": "Cursor", "url": "https://cursor.com", "snippet": "The AI code editor..." },
    { "title": "Aider", "url": "https://github.com/paul-gauthier/aider", "snippet": "AI pair programming in terminal..." }
  ],
  "model": "groq/llama-3.3-70b-versatile",
  "agent": "XavvyNess Research Engine",
  "runAt": "2026-04-08T22:21:45.123Z"
}
```

The full `report` field contains the complete structured markdown report (typically 600–2000 words for `standard` depth).

***

### Model routing (automatic)

| Depth | Model | Why |
|---|---|---|
| `quick` | Llama 3.3 70B via Groq | Sub-second inference, free tier, great for fast summaries |
| `standard` | Gemini 2.0 Flash | Best balance of speed and quality |
| `deep` | Gemini 2.5 Flash | Top reasoning for comprehensive, multi-angle analysis |

No configuration needed — routing is automatic based on your `depth` input.

***

### Use cases

- **Competitive research** — "Who are the top 5 competitors to Linear and how do they price?"
- **Technical deep-dives** — "What are the differences between RAG and fine-tuning for production LLMs?"
- **Market analysis** — "What AI agent startups received Series A funding in Q1 2026?"
- **Due diligence** — "What are the known scaling issues with Supabase at 1M+ rows?"
- **Content research** — "What are the most cited 2025 studies on remote work and productivity?"
- **Security audits** — "What CVEs affect Node.js 20 LTS as of April 2026?"

***

### Caching

Results are cached for **24 hours** per unique `query + depth + format` combination. Re-running the same query within 24h returns the cached result instantly at no additional compute cost.

***

### Cost comparison

| Tool | Pricing | Web search | Caching | Model routing |
|---|---|---|---|---|
| **XavvyNess Research Engine** | Pay-per-result | ✅ Live (Tavily) | ✅ 24h | ✅ Automatic |
| Generic GPT wrapper | High flat rate | ❌ Training data only | ❌ | ❌ |
| Basic search scraper | Per-page | ✅ | ❌ | ❌ |

***

### Integration

#### Via Apify JavaScript client

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('RBobzxRYFVgoX74uu').call({
  query: 'What is the state of open-source LLMs in 2026?',
  depth: 'standard',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].report);    // full markdown report
console.log(items[0].summary);   // 2-3 sentence summary
console.log(items[0].sources);   // array of { title, url, snippet }
```

#### Via HTTP API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/RBobzxRYFVgoX74uu/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "Best vector databases for production in 2026",
    "depth": "standard",
    "format": "markdown"
  }'
```

#### Via Make.com / Zapier

Use the **Apify** module → **Run Actor** action. Actor ID: `RBobzxRYFVgoX74uu`. Pass your query in the input JSON, then map `{{report}}` and `{{summary}}` from the output to your next step.

***

### Limitations

- Web search requires the `TAVILY_API_KEY` environment variable. Without it, the actor falls back to AI knowledge only (clearly flagged in status messages).
- `deep` depth runs may take 30–90 seconds for complex topics with many sources.
- Source quality depends on what Tavily surfaces — very niche topics may return fewer authoritative results.
- Report is generated in English regardless of query language (multi-language support planned).

***

### About XavvyNess

XavvyNess is an AI agent platform focused on practical, production-ready automation. This actor is part of a suite of research and development tools built for developers and operators who need real answers, not hallucinations.

Questions or feature requests → open an issue or contact us via the Apify Store.

# Actor input Schema

## `query` (type: `string`):

What do you want to research? Be specific for better results.

## `depth` (type: `string`):

How thorough should the research be?

## `format` (type: `string`):

Format for the research report output

## `includeSource` (type: `boolean`):

Include source citations and URLs in the report

## `maxResults` (type: `integer`):

Maximum number of findings to include

## Actor input object example

```json
{
  "query": "What are the top AI agent frameworks in 2025 and their key differences?",
  "depth": "standard",
  "format": "markdown",
  "includeSource": true,
  "maxResults": 10
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "What are the top AI agent frameworks in 2025 and their key differences?"
};

// Run the Actor and wait for it to finish
const run = await client.actor("xavvyness/xavvyness-research-engine").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "query": "What are the top AI agent frameworks in 2025 and their key differences?" }

# Run the Actor and wait for it to finish
run = client.actor("xavvyness/xavvyness-research-engine").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "What are the top AI agent frameworks in 2025 and their key differences?"
}' |
apify call xavvyness/xavvyness-research-engine --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=xavvyness/xavvyness-research-engine",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "XavvyNess AI Research Engine",
        "description": "Ask any question — get a structured, cited research report in seconds. Live web search + AI synthesis (Groq/Gemini). Returns summary, full report with numbered citations, and source URLs. Quick, Standard, and Deep depth modes. Support email: hello@xavvyness.ai",
        "version": "1.0",
        "x-build-id": "pH2naoLQSt9UDiPGi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xavvyness~xavvyness-research-engine/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xavvyness-xavvyness-research-engine",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/xavvyness~xavvyness-research-engine/runs": {
            "post": {
                "operationId": "runs-sync-xavvyness-xavvyness-research-engine",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/xavvyness~xavvyness-research-engine/run-sync": {
            "post": {
                "operationId": "run-sync-xavvyness-xavvyness-research-engine",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Research Query",
                        "type": "string",
                        "description": "What do you want to research? Be specific for better results.",
                        "default": "What are the top AI agent frameworks in 2025 and their key differences?"
                    },
                    "depth": {
                        "title": "Research Depth",
                        "enum": [
                            "quick",
                            "standard",
                            "deep"
                        ],
                        "type": "string",
                        "description": "How thorough should the research be?",
                        "default": "standard"
                    },
                    "format": {
                        "title": "Output Format",
                        "enum": [
                            "markdown",
                            "json",
                            "bullet"
                        ],
                        "type": "string",
                        "description": "Format for the research report output",
                        "default": "markdown"
                    },
                    "includeSource": {
                        "title": "Include Sources",
                        "type": "boolean",
                        "description": "Include source citations and URLs in the report",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max Findings",
                        "minimum": 3,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Maximum number of findings to include",
                        "default": 10
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```