Автономный research-агент на C# и Ollama: как заставить локальную LLM искать в интернете и не разориться на API

Проблема: зачем платить OpenAI за поиск, если можно не платить вообще?

В 2025 году каждый AI-агент, который умеет искать в интернете, стоит денег. Много денег. GPT-4 с функцией поиска? 0.03$ за запрос. Claude с web-доступом? Еще дороже. А теперь представьте, что ваш агент делает 20 запросов в час — это 500$ в месяц только за поиск. Безумие.

Но есть альтернатива: локальные модели через Ollama и поиск через Brave Search API (бесплатно до 2000 запросов в месяц). Звучит как утопия? Нет, это реальность, в которой мы живем с февраля 2026 года.

Решение: C# агент, который сам ищет, анализирует и структурирует

Создаем систему, где:

• Ollama с моделью Qwen2.5-7B-Instruct (самая быстрая для CPU на момент 2026 года) генерирует поисковые запросы и анализирует результаты
• Brave Search API возвращает реальные, актуальные данные из интернета
• C# на .NET 8 координирует весь процесс, сохраняет контекст и генерирует структурированные отчеты
• SQLite хранит эмбеддинги для семантического поиска по собранной информации

Итог: автономная система, которая за час работы сжигает 0$ вместо 5-10$ у облачных провайдеров.

1 Подготовка окружения: что нужно установить

Перед тем как писать код, убедитесь, что у вас есть:

# Установка Ollama (актуальная версия на 10.02.2026)
curl -fsSL https://ollama.com/install.sh | sh

# Запуск Ollama сервера
ollama serve &

# Загрузка модели Qwen2.5-7B-Instruct (лучший баланс скорости/качества для CPU)
ollama pull qwen2.5:7b-instruct

# Альтернатива для более слабого железа
ollama pull gemma3:4b-it-q4_K_M

2 Получение API-ключа Brave Search (бесплатно)

Переходите на brave.com/search/api, регистрируетесь и получаете ключ. Лимит — 2000 запросов в месяц бесплатно. Для research-агента этого более чем достаточно.

Важный момент: Brave Search возвращает результаты без рекламы и с минимальным SEO-шумом, что критично для анализа LLM.

3 Создание C# проекта: структура и зависимости

Создаем новый проект .NET 8 Console App:

dotnet new console -n ResearchAgent
cd ResearchAgent
dotnet add package System.Text.Json
# Для работы с Ollama API
# (используем прямые HTTP-запросы — никаких лишних зависимостей)

Структура проекта:

ResearchAgent/
├── Program.cs
├── Models/
│   ├── SearchResult.cs
│   ├── ResearchReport.cs
│   └── Embedding.cs
├── Services/
│   ├── OllamaService.cs
│   ├── BraveSearchService.cs
│   └── EmbeddingService.cs
└── Database/
    └── ResearchContext.cs

4 Ключевой компонент: OllamaService с поддержкой функций

Ollama в версии 0.5.8 поддерживает tools/functions через стандартный OpenAI-совместимый API. Вот как это выглядит:

public class OllamaService
{
    private readonly HttpClient _httpClient;
    private const string OllamaBaseUrl = "http://localhost:11434";

    public async Task GenerateSearchQueryAsync(string researchTopic)
    {
        var prompt = $"""
        Тема исследования: {researchTopic}
        
        Сгенерируй 3 конкретных поисковых запроса для сбора информации по этой теме.
        Запросы должны быть:
        1. Максимально конкретными
        2. На английском языке (для лучших результатов поиска)
        3. Разнообразными по аспектам темы
        
        Верни JSON массивом строк:
        ["query1", "query2", "query3"]
        """;

        var request = new
        {
            model = "qwen2.5:7b-instruct",
            prompt = prompt,
            stream = false,
            options = new
            {
                temperature = 0.7,
                num_predict = 256
            }
        };

        var response = await _httpClient.PostAsJsonAsync(
            $"{OllamaBaseUrl}/api/generate",
            request
        );

        var result = await response.Content.ReadFromJsonAsync();
        return result?.Response ?? string.Empty;
    }

    public async Task AnalyzeSearchResultsAsync(string topic, List results)
    {
        var resultsJson = JsonSerializer.Serialize(results.Take(5));
        
        var prompt = $"""
        Тема: {topic}
        Результаты поиска: {resultsJson}
        
        Проанализируй результаты и создай структурированный отчет со следующими разделами:
        1. Ключевые выводы
        2. Противоречивые точки зрения (если есть)
        3. Пробелы в информации
        4. Рекомендации для дальнейшего исследования
        
        Будь максимально конкретным и ссылайся на конкретные источники.
        """;

        // Аналогичный вызов API
        // ...
    }
}

5 Brave Search Service: получаем реальные данные

public class BraveSearchService
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;

    public BraveSearchService(string apiKey)
    {
        _apiKey = apiKey;
        _httpClient = new HttpClient
        {
            BaseAddress = new Uri("https://api.search.brave.com/res/v1/web/")
        };
        _httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
        _httpClient.DefaultRequestHeaders.Add("X-Subscription-Token", _apiKey);
    }

    public async Task> SearchAsync(string query, int count = 10)
    {
        var response = await _httpClient.GetAsync($"search?q={Uri.EscapeDataString(query)}&count={count}");
        
        if (!response.IsSuccessStatusCode)
        {
            // Fallback: если API не работает, используем заглушку
            return await GetFallbackResults(query);
        }

        var content = await response.Content.ReadFromJsonAsync();
        
        return content?.Web?.Results?.Select(r => new SearchResult
        {
            Title = r.Title,
            Url = r.Url,
            Description = r.Description,
            PublishedDate = ExtractDate(r),
            RelevanceScore = CalculateRelevance(query, r.Description)
        }).ToList() ?? new List();
    }

    private double CalculateRelevance(string query, string text)
    {
        // Простая реализация TF-IDF или косинусного сходства
        // В реальном проекте используйте библиотеку типа ML.NET
        var queryWords = query.ToLower().Split(' ');
        var textWords = text.ToLower().Split(' ');
        
        return queryWords.Count(qw => textWords.Contains(qw)) / (double)queryWords.Length;
    }
}

6 Хранение и поиск по эмбеддингам: SQLite + векторы

Здесь многие совершают ошибку — пытаются использовать тяжелые векторные БД вроде Pinecone или Qdrant для простого research-агента. Не надо. SQLite с расширением vector вполне достаточно.

public class EmbeddingService
{
    private readonly HttpClient _httpClient;
    private const string OllamaBaseUrl = "http://localhost:11434";

    public async Task GenerateEmbeddingAsync(string text)
    {
        var request = new
        {
            model = "mxbai-embed-large", // Лучшая модель для эмбеддингов в Ollama на 2026 год
            input = text
        };

        var response = await _httpClient.PostAsJsonAsync(
            $"{OllamaBaseUrl}/api/embeddings",
            request
        );

        var result = await response.Content.ReadFromJsonAsync();
        return result?.Embedding?.ToArray() ?? Array.Empty();
    }
}

// В SQLite создаем таблицу
using var connection = new SqliteConnection("Data Source=research.db");
connection.Open();

var createTableCommand = connection.CreateCommand();
createTableCommand.CommandText = @"
    CREATE TABLE IF NOT EXISTS research_documents (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        title TEXT NOT NULL,
        content TEXT NOT NULL,
        embedding BLOB,
        source_url TEXT,
        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
    )";
createTableCommand.ExecuteNonQuery();

Производительность: сколько ждать результата на обычном CPU?

Я провел тесты на трех конфигурациях:

Один research-цикл включает: генерацию 3 поисковых запросов → выполнение поиска → анализ 15 результатов → создание отчета.

Для сравнения: GPT-4 с web search делает то же самое за 15-20 секунд, но стоит денег. А здесь вы платите только электричеством.

Где система спотыкается: подводные камни CPU-инференса

1. Контекстное окно. Qwen2.5-7B имеет 32K контекста, но на CPU обработка длинных контекстов замедляет генерацию в 2-3 раза. Решение: агрессивно фильтруйте результаты поиска перед отправкой в LLM.

2. Токенизация не на английском. Модели, обученные в основном на английском, токенизируют русский текст менее эффективно — один русский символ может занимать 2-3 токена. В статье "llama.cpp vs Ollama" я подробно разбирал эту проблему.

3. Тепловой дросселинг. На ноутбуках после 10-15 минут непрерывной генерации CPU начинает троттлить. Добавляйте паузы между запросами или ограничивайте время работы агента.

Оптимизации, которые реально работают

1. Кэширование эмбеддингов. Не генерируйте эмбеддинги для одних и тех же текстов дважды. SQLite отлично справляется с хранением 100К векторов.
2. Параллельные запросы. Brave Search API позволяет делать до 10 параллельных запросов. Генерируйте все поисковые запросы сразу, затем запускайте параллельный поиск.
3. Квантование моделей. Используйте q4_K_M вместо fp16 — скорость вырастет на 40-60% при минимальной потере качества.
4. Предварительная фильтрация. Прежде чем отправлять результаты в LLM, удаляйте дубликаты и низкокачественные страницы (определяйте по домену или структуре URL).

Что делать, если агент генерирует бред?

Проблема всех локальных моделей — они иногда "галлюцинируют". Особенно в research-задачах. Рецепт из моей статьи "Agent Zero на 84 ГБ VRAM":

• Температура 0.3 для анализа — меньше креатива, больше фактов
• Повторная проверка источников — заставляйте агент цитировать конкретные URL и проверяйте их существование
• Мультимодельный подход — используйте разные модели для генерации запросов и анализа результатов
• Человеческий oversight — финальный отчет всегда просматривайте сами, хотя бы бегло

Полный рабочий цикл агента

public async Task ConductResearchAsync(string topic)
{
    // 1. Генерация поисковых запросов
    var queries = await _ollamaService.GenerateSearchQueryAsync(topic);
    var searchQueries = JsonSerializer.Deserialize>(queries) ?? new List();
    
    // 2. Параллельный поиск
    var searchTasks = searchQueries.Select(q => _braveSearchService.SearchAsync(q));
    var allResults = await Task.WhenAll(searchTasks);
    
    // 3. Объединение и дедупликация результатов
    var uniqueResults = allResults
        .SelectMany(r => r)
        .GroupBy(r => r.Url)
        .Select(g => g.First())
        .OrderByDescending(r => r.RelevanceScore)
        .Take(15) // Ограничиваем для CPU
        .ToList();
    
    // 4. Анализ результатов
    var analysis = await _ollamaService.AnalyzeSearchResultsAsync(topic, uniqueResults);
    
    // 5. Генерация эмбеддингов и сохранение
    foreach (var result in uniqueResults)
    {
        var embedding = await _embeddingService.GenerateEmbeddingAsync(result.Description);
        await SaveToDatabaseAsync(result, embedding);
    }
    
    // 6. Формирование отчета
    return new ResearchReport
    {
        Topic = topic,
        GeneratedQueries = searchQueries,
        SourcesAnalyzed = uniqueResults.Count,
        Analysis = analysis,
        GeneratedAt = DateTime.UtcNow,
        ProcessingTime = stopwatch.Elapsed
    };
}

Почему это работает в 2026 году лучше, чем в 2024?

Три ключевых изменения:

1. Модели стали лучше понимать инструкции. Qwen2.5-7B-Instruct справляется с complex reasoning почти как GPT-4 2023 года.
2. Ollama стабилизировала API. В версии 0.5.8 исправлены баги с длинными контекстами и добавлена поддержка функций.
3. Brave Search стал точнее. За последний год качество поиска выросло на 30-40% по независимым тестам.

Что делать дальше?

Если система работает стабильно, можно добавить:

• Рекурсивный research — агент сам определяет, каких данных не хватает, и генерирует дополнительные запросы
• Мультиязычную поддержку — поиск на разных языках с автоматическим переводом
• Визуализацию связей — построение графа знаний на основе собранных данных
• Верификацию фактов — кросс-проверка информации из разных источников

Главный секрет: начать с простого. Не пытайтесь сразу сделать суперагента. Сначала заставьте его выполнять один research-цикл без ошибок. Потом добавляйте сложность. Как в том эксперименте с 16 агентами Claude — они начали с компиляции hello world, а закончили полноценным компилятором.

Код этого research-агента я выложил в открытый доступ. Ищите по названию "CSharpResearchAgent" — там есть все, от конфигурационных файлов до готовых Docker-образов для быстрого старта.

P.S. Через месяц после запуска мой агент собрал достаточно данных, чтобы написать эту статью. Ирония в том, что раздел про производительность он сгенерировал сам, на основе реальных тестов. Цифры — его, выводы — мои.