Struct Args 

pub struct Args {

    pub model: Option<String>,
    pub log_level: String,
    pub scripting_env: Option<String>,
    pub event_handler_mode: Option<String>,
    pub listen_addr: Option<String>,
    pub include_disabled_protocols: bool,
    pub min_stability: Option<String>,
    pub ollama_lock: bool,
    pub ollama_url: Option<String>,
    pub openai_url: Option<String>,
    pub api_key: Option<String>,
    pub llm_agent: bool,
    pub llm_agent_pipe: Option<PathBuf>,
    pub llm_agent_timeout: u64,
    pub llm_request_timeout: Option<u64>,
    pub llm_max_tokens: Option<u32>,
    pub llm_seed: Option<u64>,
    pub llm_temperature: Option<f32>,
    pub embedded_model: Option<PathBuf>,
    pub use_embedded: bool,
    pub theme: String,
    pub show_art: bool,
    pub suppress_art: bool,
    pub llm_max_concurrent: Option<usize>,
    pub llm_queue_timeout: Option<u64>,
    pub llm_max_queued: Option<usize>,
    pub llm_token_limit: Option<u64>,
    pub llm_token_window: u64,
    pub no_scripts: bool,
    pub load_file: Option<String>,
    pub exit_after_events: Option<u64>,
    pub run_for: Option<u64>,
    pub mock_config_file: Option<PathBuf>,
    pub simple_protocol: Option<String>,
    pub simple_list: bool,
    pub client_protocol: Option<String>,
    pub client_addr: Option<String>,
    pub client_params: Option<String>,
    pub client_handlers: Option<String>,
    pub client_list: bool,
    pub server_protocol: Option<String>,
    pub server_port: Option<u16>,
    pub server_params: Option<String>,
    pub docs: bool,
    pub mcp_stdio: bool,
    pub mcp_http: Option<u16>,
    pub mcp_token: Option<String>,
    pub prompt: Vec<String>,
}

NetGet - LLM-Controlled Network Application

Fields

model: Option<String>

LLM model to use (e.g., “llama3.2:latest”, “deepseek-coder:latest”)

log_level: String

Log level (off, error, warn, info, debug, trace) Development builds default to ‘debug’, release builds default to ‘info’ (‘trace’ additionally writes full network payloads and LLM prompts to netget.log)

scripting_env: Option<String>

Scripting environment to use (on, off, python, javascript, go, perl)

event_handler_mode: Option<String>

Event handler mode to use (any, script, static, llm)

listen_addr: Option<String>

Bind address for the MCP HTTP control endpoint (default: 127.0.0.1)

Read only by --mcp-http. Protocol servers take their bind address from each start_server / open_server call’s host, not from this flag.

include_disabled_protocols: bool

Include disabled protocols (for testing honeypot-only protocols like IPSec, OpenVPN)

min_stability: Option<String>

Refuse to start any protocol below this maturity level

ollama_lock: bool

DEPRECATED AND IGNORED. Accepted for compatibility only; it locks nothing.

ollama_url: Option<String>

Ollama API base URL (default: http://localhost:11434)

openai_url: Option<String>

OpenAI-compatible API base URL (e.g., “https://api.openai.com”, “http://localhost:1234”)

api_key: Option<String>

API key for OpenAI-compatible endpoint (prefer the environment variable)

llm_agent: bool

Route all LLM calls to the calling MCP agent instead of a model (MCP mode only)

llm_agent_pipe: Option<PathBuf>

FIFO path for agent-queue push notifications

llm_agent_timeout: u64

Seconds a queued LLM request waits for the agent’s answer before erroring

llm_request_timeout: Option<u64>

Wall-clock bound (seconds) on a single LLM backend call

llm_max_tokens: Option<u32>

Completion-token budget for a single LLM call

llm_seed: Option<u64>

Sampler seed sent to the LLM backend

llm_temperature: Option<f32>

Sampling temperature sent to the LLM backend

embedded_model: Option<PathBuf>

Path to embedded GGUF model file (enables embedded LLM inference)

use_embedded: bool

Force use of embedded LLM backend (skip Ollama)

theme: String

Terminal color theme (auto, light, dark, neutral)

show_art: bool

Show the generated ASCII art banner on startup (off by default)

--suppress-art is kept as a hidden no-op so existing scripts and the test harness keep working now that suppressing is the default.

suppress_art: bool

llm_max_concurrent: Option<usize>

Maximum concurrent LLM requests (default: 1)

llm_queue_timeout: Option<u64>

How long a network request waits for a concurrency permit

llm_max_queued: Option<usize>

How many network requests may wait for a concurrency permit at once

llm_token_limit: Option<u64>

Token limit per time window (optional, for cloud API usage control)

llm_token_window: u64

Token limit time window in seconds (default: 60)

no_scripts: bool

Disable scripting (LLM will only use actions, no script generation)

load_file: Option<String>

Load server/client configuration from a .netget file

exit_after_events: Option<u64>

Non-interactive only: exit (status 0) once this many network events have been handled across every server and client.

run_for: Option<u64>

Non-interactive only: exit (status 0) after this many seconds.

mock_config_file: Option<PathBuf>

Path to mock LLM configuration file (for testing)

simple_protocol: Option<String>

Start a simple protocol (simplified LLM interface for “dumb” models)

simple_list: bool

List available simple protocols

client_protocol: Option<String>

Connect a protocol client to a remote server (non-interactive)

client_addr: Option<String>

Remote address for –client

client_params: Option<String>

Startup parameters for –client

client_handlers: Option<String>

Event handlers for –client

client_list: bool

List available client protocols

server_protocol: Option<String>

Start a server of PROTOCOL directly, skipping the initial model call

server_port: Option<u16>

Listen port for –server

server_params: Option<String>

Startup parameters for –server

docs: bool

Print documentation for every protocol and exit

mcp_stdio: bool

Run as MCP STDIO server (for Claude Desktop/Code integration)

mcp_http: Option<u16>

Run as an MCP server over HTTP/SSE on the given port (for remote/web MCP clients)

mcp_token: Option<String>

Bearer token every –mcp-http request must carry

prompt: Vec<String>

Prompt/command to execute (can be specified after –, or as trailing args, or via stdin)

Implementations

impl Args

pub fn resolve_api_key(&self) -> Option<String>

Resolve the API key from NETGET_API_KEY / OPENAI_API_KEY, or the --api-key flag.

The flag still wins when both are set - changing that would break callers - but using it warns, because it exposes the secret in the process table.

pub fn resolve_mcp_token(&self) -> Option<String>

Resolve the MCP HTTP bearer token from --mcp-token or NETGET_MCP_TOKEN.

Same shape as resolve_api_key: the flag wins and warns, the variable is the documented way in. An empty value counts as unset.

pub fn effective_log_level(&self) -> Level

Get the effective log level from –log-level flag

pub fn logging_disabled(&self) -> bool

Check if logging should be disabled entirely

pub fn is_interactive(&self) -> bool

Determine if we should run in interactive mode

pub fn get_prompt(&self) -> Result<Option<String>>

Get the prompt to execute, from various sources Returns None if the input should be treated as actions JSON instead

pub fn get_actions_json(&self) -> Result<Option<Vec<Value>>>

Get actions JSON to execute, from various sources Returns None if the input is a regular prompt or no input

pub fn validate_mode(&self) -> Result<()>

Check if the environment is suitable for the requested mode

pub fn parse_scripting_mode(&self) -> Result<Option<ScriptingMode>>

Parse the scripting environment argument into a ScriptingMode

pub fn parse_event_handler_mode(&self) -> Result<Option<EventHandlerMode>>

Parse the event handler mode argument into an EventHandlerMode

pub fn client_instruction(&self, protocol: &str, remote_addr: &str) -> String

Instruction for a --client: the trailing text if any was given, otherwise the same default the MCP start_client tool uses.

pub fn server_instruction(&self, protocol: &str) -> String

The per-request instruction for --server: the trailing prompt, or a minimal default naming the protocol when none was given.

pub fn parse_server_params(&self) -> Result<Option<Value>>

Parse --server-params into a JSON object.

pub fn parse_client_params(&self) -> Result<Option<Value>>

Parse --client-params into a JSON object

pub fn parse_client_handlers(&self) -> Result<Option<Vec<Value>>>

Parse --client-handlers into a list of event handler definitions

pub fn parse_min_stability(&self) -> Result<Option<DevelopmentState>>

Parse --min-stability into a [DevelopmentState].

Returns Ok(None) when the flag is absent (no gate — current behaviour). An unrecognised value is a hard error naming the allowed set, mirroring parse_scripting_mode/parse_event_handler_mode.

pub fn build_rate_limiter_config(&self) -> RateLimiterConfig

Build a RateLimiterConfig from CLI arguments

Trait Implementations

impl Args for Args

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl CommandFactory for Args

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl Debug for Args

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Args

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Args

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.