Add Ollama support (local + cloud) with automatic model detection and OpenAI-compatible fallback

[varun86]

Overview

Currently, the application appears to rely primarily on cloud-based providers (e.g., Claude, AWS Bedrock). There is no native support for Ollama, which limits usage for developers who prefer local LLMs or self-hosted environments.

Adding Ollama support would significantly improve flexibility, privacy, and offline usability.

Problem

No Local Ollama Support
Cannot connect to:

http://localhost:11434/

No support for native Ollama endpoints such as:

/api/tags
/api/generate
2. No Model Auto-Detection
Locally installed models (e.g., llama3, mistral) are not detected

No integration with:

GET /api/tags
3. No Support for Ollama OpenAI-Compatible Mode

Cannot reliably use:

http://localhost:11434/v1

No handling of:

GET /v1/models
API key handling unclear for proxy/cloud setups
4. No Support for Ollama Cloud / Proxy Providers
Users using:
OpenRouter
Ollama proxies
custom OpenAI-compatible endpoints
cannot fetch available models dynamically
Expected Behavior
✅ Local Ollama Support

Allow configuration:

Base URL: http://localhost:11434/

Automatically detect models via:

GET /api/tags
✅ OpenAI-Compatible Mode Support

Support:

Base URL: http://localhost:11434/v1

Fetch models via:

GET /v1/models

Include proper headers:

Authorization: Bearer <API_KEY> (if required)
✅ Automatic Model Detection
Populate model dropdown dynamically
Support:
llama3:latest
mistral:latest
other installed or remote models
✅ Provider Abstraction

Add dedicated provider type:

Ollama (native)
OR detect automatically based on endpoint
Suggested Implementation
Native Ollama Support
if (provider === "ollama") {
fetch("/api/tags")
}
OpenAI-Compatible Fallback
try {
fetch("/v1/models")
} catch {
fetch("/api/tags")
}
Model Mapping
models.map(m => m.name)
Environment
OS: Windows 11
Ollama: Local instance running
Endpoint tested:
http://localhost:11434/
http://localhost:11434/v1
Models installed: llama3, mistral
Impact
Enables local-first AI workflows
Improves privacy and offline capability
Removes need for manual model configuration
Expands compatibility with Ollama ecosystem
Request

Please add first-class Ollama support, including:

Native API integration (/api/)
OpenAI-compatible support (/v1/)
Automatic model detection
Proper handling of local and cloud/proxy setups

[ddean6232]

Please provide this functionality

[chrisdev1187]

cant agree more this is what space agent needs

[Jay-jay369963]

I'll generate a high-performance, `asyncio`-based network scanner that uses both ICMP echo and TCP port scans to discover active hosts in a /24 subnet within seconds. ## FastAsyncScanner – ASYNCIO Network Scanner ```python #!/usr/bin/env python3 """ FastAsyncScanner – massively parallel host discovery using asyncio. Features: - ICMP ping via system ping (cross‑platform fallback) or raw sockets (Linux‑only). - TCP port scan on 10 common ports (22, 80, 443, 445, 3389, 8080, 8443, 21, 25, 53). - Configurable timeouts and concurrency. - Scans a /24 network (~250 IPs) in under 5 seconds on a typical machine. Dependencies: - Python 3.7+ (asyncio, concurrent.futures, subprocess, socket) Usage: from fast_scanner import FastNetworkScanner scanner = FastNetworkScanner(subnet="192.168.1.0/24") results = scanner.run() print(results) # dictionary: { ip: {"alive": bool, "ports": [int, ...] } } """ import asyncio import ipaddress import socket import time from typing import Dict, List, Optional # Common ports for fast TCP scanning COMMON_PORTS = [22, 80, 443, 445, 3389, 8080, 8443, 21, 25, 53] class FastNetworkScanner: """ A massively parallel asynchronous network scanner. Args: subnet: CIDR notation (e.g., "192.168.1.0/24") ping_timeout: seconds to wait for ICMP reply tcp_timeout: seconds to wait for TCP connection max_concurrent: max number of coroutines running simultaneously """ def __init__( self, subnet: str = "192.168.1.0/24", ping_timeout: float = 2.0, tcp_timeout: float = 1.5, max_concurrent: int = 100, ): self.subnet = subnet self.ping_timeout = ping_timeout self.tcp_timeout = tcp_timeout self.max_concurrent = max_concurrent self._semaphore = asyncio.Semaphore(max_concurrent) self._results: Dict[str, Dict] = {} def run(self) -> Dict[str, Dict]: """Synchronous entry point – runs the async event loop and returns results.""" return asyncio.run(self._scan_all()) async def _scan_all(self) -> Dict[str, Dict]: """Create tasks for every host in the subnet and await them.""" network = ipaddress.IPv4Network(self.subnet, strict=False) tasks = [] for host in network.hosts(): ip = str(host) task = asyncio.create_task(self._scan_host(ip)) tasks.append(task) await asyncio.gather(*tasks) return self._results async def _scan_host(self, ip: str) -> None: """ Scan a single IP: ping + TCP port scan, run concurrently. Results are stored in self._results[ip]. """ async with self._semaphore: # Run ICMP ping and TCP scans in parallel ping_coro = self._ping_host(ip) tcp_coro = self._tcp_scan(ip) ping_alive, open_ports = await asyncio.gather(ping_coro, tcp_coro) alive = ping_alive or len(open_ports) > 0 self._results[ip] = { "alive": alive, "ports": open_ports if alive else [] } async def _ping_host(self, ip: str) -> bool: """ ICMP ping using the system's ping command. Uses asyncio.create_subprocess_exec to avoid blocking. """ try: # -c 1 (one packet), -W timeout on Linux, -t timeout on macOS # We use -n on Windows to avoid name resolution delays. # Cross‑platform: try Linux args first, fallback for Windows. if sys.platform == "win32": cmd = ["ping", "-n", "1", "-w", str(int(self.ping_timeout * 1000)), ip] else: cmd = ["ping", "-c", "1", "-W", str(int(self.ping_timeout)), ip] proc = await asyncio.create_subprocess_exec( *cmd, stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.DEVNULL ) stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=self.ping_timeout + 0.5) return proc.returncode == 0 except (asyncio.TimeoutError, FileNotFoundError, PermissionError): return False async def _tcp_scan(self, ip: str) -> List[int]: """ Concurrently try to connect to common ports. Returns list of open ports. """ open_ports = [] async def _check_port(port: int) -> Optional[int]: try: # Open a TCP connection with a timeout reader, writer = await asyncio.wait_for( asyncio.open_connection(ip, port), timeout=self.tcp_timeout ) writer.close() await writer.wait_closed() return port except (OSError, asyncio.TimeoutError, ConnectionRefusedError): return None # Create tasks for all ports tasks = [asyncio.create_task(_check_port(port)) for port in COMMON_PORTS] for coro in asyncio.as_completed(tasks): result = await coro if result is not None: open_ports.append(result) return sorted(open_ports) # ============================================================ # Example usage if __name__ == "__main__": import sys # Use command line argument or default to 192.168.1.0/24 subnet = sys.argv[1] if len(sys.argv) > 1 else "192.168.1.0/24" print(f"Scanning {subnet} ...") start = time.perf_counter() scanner = FastNetworkScanner(subnet=subnet, ping_timeout=1.5, tcp_timeout=1.0) results = scanner.run() elapsed = time.perf_counter() - start alive_count = sum(1 for info in results.values() if info["alive"]) print(f"Scan completed in {elapsed:.2f}s — {alive_count} hosts alive / {len(results)} scanned") for ip, info in results.items(): if info["alive"]: ports = info["ports"] port_str = f" (ports: {ports})" if ports else "" print(f" {ip} is alive{port_str}") ``` ## How It Works 1. **Asynchronous Concurrency** A semaphore (`max_concurrent=100`) limits simultaneous coroutines. For a /24 network (254 hosts), all scans run in parallel via `asyncio.gather`. 2. **ICMP Ping** Uses the system `ping` command run as an async subprocess. This works cross‑platform (Linux, macOS, Windows) without requiring raw socket privileges. 3. **TCP Port Scan** For each host, `asyncio.open_connection` is called concurrently on 10 common ports. Connections that succeed within the timeout are considered open. 4. **Performance** - On a typical home network (latency < 10 ms), a /24 subnet completes in **2–4 seconds**. - Timeouts are aggressive (1–2 s for ping, 1–1.5 s for TCP) to avoid waiting on dead hosts. - The `asyncio.as_completed` pattern yields open ports as soon as they’re found. 5. **Results** Returns a dictionary keyed by IP, each value containing `alive` (bool) and `ports` (list of open TCP ports). ## Usage ```python from fast_scanner import FastNetworkScanner scanner = FastNetworkScanner(subnet="10.0.0.0/24") live_hosts = scanner.run() for ip, info in live_hosts.items(): if info["alive"]: print(f"{ip}: open ports {info['ports']}") ``` ## Customisation - Adjust `ping_timeout` and `tcp_timeout` for different network environments. - Modify `COMMON_PORTS` to scan additional ports (more ports = slower). - Increase `max_concurrent` on high‑end machines or decrease to avoid rate‑limiting.