Integuru

Automates browser-based HTTP traffic capture using Playwright-controlled Chromium, recording all network requests/responses in HAR (HTTP Archive) format alongside authentication cookies and session tokens. The system spawns a headless browser instance, allows manual user interaction including 2FA flows, and persists complete network logs with metadata for downstream LLM analysis. This approach captures real API calls as they occur in production web applications without requiring API documentation.

Uses semantic LLM analysis to identify which HTTP request in a captured HAR file accomplishes the user's stated goal, without requiring prior knowledge of API structure. The system sends the HAR entries and a natural language prompt (e.g., 'create a new task') to an LLM, which analyzes request patterns, response structures, and semantics to pinpoint the primary action endpoint. This enables users to specify intent in plain English rather than manually locating the correct API call.

Captures and preserves authentication cookies, session tokens, and headers from the initial HAR capture, then applies them to generated code to maintain authenticated sessions across multi-step request sequences. Handles cookie expiration, token refresh patterns (when detectable from HAR), and header-based authentication (Bearer tokens, API keys). Enables generated code to execute without requiring users to manually manage authentication state.

Generates request body templates and parameter specifications for each request node in the dependency graph, identifying which fields are static vs dynamic and creating variable placeholders for dynamic values. Produces Python code with f-strings or format() calls for parameter substitution, enabling generated functions to accept dynamic values as arguments and construct proper request bodies. Handles JSON, form-encoded, and multipart request bodies.

Analyzes HTTP response bodies from captured requests to identify and extract values that are used as parameters in downstream requests. Handles JSON, HTML, and form-encoded responses, using LLM semantic analysis to locate relevant data fields (IDs, tokens, URLs) within responses. Generates extraction code (JSON path, regex, or parsing logic) that can be applied to live API responses during execution.

Identifies which URL parameters, headers, request body fields, and cookies contain dynamic values (non-static data that varies between requests) using LLM semantic analysis. The system analyzes request patterns across the HAR file to detect fields that change between calls (e.g., user IDs, timestamps, CSRF tokens, pagination cursors) and marks them as dependencies requiring upstream resolution. This enables the system to distinguish between static configuration and values that must be sourced from other API responses.

Builds a directed acyclic graph (DAG) of API request dependencies by recursively tracing dynamic values backward through the HAR file to their source responses. For each dynamic parameter identified in the target request, the system searches earlier requests' responses to find where that value originated, then repeats the process for those upstream requests until reaching base requests that only require authentication cookies. Uses NetworkX for graph representation and topological ordering, enabling visualization and execution planning of the complete request chain.

Converts the constructed dependency DAG into executable Python code by generating a function for each graph node with proper parameter passing and sequencing. The system uses LLM analysis to infer function signatures, handle authentication, manage session state, and implement error handling based on observed request patterns. Generated code includes type hints, docstrings, and proper async/await patterns where applicable, producing production-ready integration code that replicates the captured workflow.

Provides abstraction layer for LLM interactions supporting multiple providers (OpenAI, Anthropic, local models via Ollama) through a unified interface. The system uses LangChain for provider abstraction, enabling users to swap LLM backends without code changes. Handles token counting, context window management, and provider-specific API differences transparently, allowing cost optimization and model selection based on task complexity.

Provides Jupyter notebook interface for step-by-step HAR analysis, dependency graph visualization, and generated code inspection. Users can interactively explore captured requests, visualize the dependency DAG, inspect LLM reasoning at each step, and iteratively refine analysis parameters. Enables debugging of failed dependency detection and manual correction of misidentified relationships before code generation.

Provides CLI entry point for automated, non-interactive HAR analysis and Python code generation suitable for CI/CD pipelines and batch processing. Accepts HAR files, configuration parameters, and natural language prompts via command-line arguments, producing generated code and analysis reports without requiring user interaction. Supports output to files, stdout, and optional JSON reports for integration with downstream tools.

Parses HAR files (JSON format) and normalizes HTTP request/response data into structured objects for downstream analysis. Handles HAR format variations, extracts relevant metadata (headers, cookies, body, timing), and validates data integrity. Provides utilities for filtering requests by criteria (URL patterns, methods, status codes) and accessing request/response pairs with proper association.

Uses LangGraph's StateGraph pattern to orchestrate multi-step analysis workflow with explicit state management and conditional branching. Each analysis step (target identification, dynamic detection, dependency tracing, code generation) is a graph node with defined inputs/outputs and state transitions. Enables resumable analysis, step-by-step debugging, and conditional execution based on intermediate results.