neam-lang/Neam

neam-lang/Neam

Neam - An agentic AI programming language for building intelligent agents

  • Stars: 7
  • Forks: 3
  • Watchers: 7
  • Open issues: 0
  • License: Apache License 2.0
  • Default branch: main
  • Created: 2026-01-20T08:27:34Z

Languages

  • C++
  • CMake
  • Dockerfile
  • Go
  • HTML
  • Python
  • Rust
  • Shell

Top Contributors

  • Praveengovianalytics (110 contributions)
  • praveengovi (55 contributions)
  • samsuljahith (2 contributions)

README

Neam

The programming language for AI agents. v1.2.0 (NeamProd)

Neam is a compiled domain-specific language for building AI agent systems. It provides first-class support for LLM providers, RAG (Retrieval-Augmented Generation), multi-agent orchestration, OWASP security compliance, knowledge management, enterprise governance, plugin extensibility, session persistence, structured evaluation, streaming, and multi-cloud deployment — all in a clean, expressive syntax.

Install

curl -fsSL https://raw.githubusercontent.com/neam-lang/Neam/main/install.sh | bash
agent Assistant {
  provider: "openai",
  model: "gpt-4o-mini",
  system: "You are a helpful assistant."
}
 
let answer = Assistant.ask("What is the capital of France?");
emit answer;

Setup

Prerequisites

RequirementVersion
C++ compilerC++20 (GCC 12+, Clang 15+, MSVC 2022+)
CMake3.20+
libcurlAny recent version
OpenSSL1.1+ (for crypto and AWS Bedrock signing)

Build from Source

git clone https://github.com/neam-lang/Neam.git
cd Neam
 
mkdir -p build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build . --parallel

This produces two binaries:

BinaryPurpose
neamcCompiler — compiles .neam source to .neamb bytecode
neam-cliRuntime — executes bytecode, includes interactive REPL

Verify Installation

# Compile and run a program
echo '{ emit 1 + 2; }' > hello.neam
./neamc hello.neam -o hello.neamb
./neam-cli hello.neamb
# Output: 3
 
# Or use the interactive REPL
./neam-cli
neam> 1 + 2
3
neam> let x = "hello"
neam> x
hello

Run Tests

cd build
ctest --output-on-failure

Quick Start

Hello World

print("Hello, Neam!");

Variables and Functions

let name = "World";
const MAX = 100;
 
fun greet(who) {
  return "Hello, " + who + "!";
}
 
emit greet(name);

Control Flow

let i = 0;
while (i < 5) {
  print(i);
  i = i + 1;
}
 
for (item in [10, 20, 30]) {
  print(item);
}

Agents

Agents are the core abstraction. An agent wraps an LLM provider with a system prompt and calls it via .ask().

agent QA {
  provider: "openai",
  model: "gpt-4o-mini",
  system: "Answer questions concisely in one sentence."
}
 
let answer = QA.ask("What is the speed of light?");
emit answer;

Supported Providers

ProviderValueAuth
Ollama (local)"ollama"None
OpenAI"openai"OPENAI_API_KEY env var
AWS Bedrock"bedrock"AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY

Local LLM (Ollama)

agent LocalBot {
  provider: "ollama",
  model: "qwen2.5:14b",
  system: "You are a coding assistant.",
  endpoint: "http://localhost:11434"
}

Multi-Agent Pipeline

Chain agents together for complex workflows:

agent Researcher {
  provider: "openai",
  model: "gpt-4o",
  system: "Research topics thoroughly. Cite sources."
}
 
agent Writer {
  provider: "openai",
  model: "gpt-4o-mini",
  system: "Write clear, engaging articles from research notes."
}
 
agent Editor {
  provider: "openai",
  model: "gpt-4o-mini",
  system: "Edit for grammar, clarity, and accuracy."
}
 
let research = Researcher.ask("Latest developments in quantum computing");
let draft = Writer.ask("Write a 500-word article based on: " + research);
let final = Editor.ask("Edit this article: " + draft);
emit final;

Full Agent Configuration

agent Analyst {
  provider: "openai",
  model: "gpt-4o",
  system: "You are a data analyst.",
  temperature: 0.3,
  api_key_env: "OPENAI_API_KEY",
  skills: [Calculator, WebSearch],
  connected_knowledge: [CompanyDocs],
  guardchains: [SafetyChain],
  budget: AnalysisBudget,
  env: Production,
  memory: SessionMemory
}

Knowledge Bases (RAG)

Connect agents to documents for grounded answers.

knowledge ProductDocs {
  vector_store: "usearch",
  embedding_model: "nomic-embed-text",
  chunk_size: 200,
  chunk_overlap: 50,
  sources: [
    { type: "file", path: "./docs/readme.md" },
    { type: "file", path: "./docs/api.md" }
  ]
}
 
agent Support {
  provider: "openai",
  model: "gpt-4o-mini",
  system: "Answer using the product documentation.",
  connected_knowledge: [ProductDocs]
}
 
let answer = Support.ask("How do I install the CLI?");

7 Retrieval Strategies

StrategyDescription
"basic"Standard vector similarity search
"mmr"Maximal Marginal Relevance — diversity-aware results
"hybrid"Combined keyword + vector search
"hyde"Hypothetical Document Embeddings
"self_rag"Self-reflective retrieval with relevance checks
"crag"Corrective RAG with query decomposition
"agentic"Tool-based retrieval with planning and reflection
knowledge SmartKB {
  vector_store: "usearch",
  embedding_model: "nomic-embed-text",
  chunk_size: 200,
  chunk_overlap: 50,
  sources: [{ type: "file", path: "./data.md" }],
  retrieval_strategy: "hybrid",
  top_k: 5
}

Skills and Tools

Skills

Extend agents with callable functions:

skill Calculator {
  description: "Performs arithmetic calculations",
  params: [
    { name: "expression", schema: { "type": "string", "description": "Math expression" } }
  ],
  impl: fun(expression) {
    return eval_math(expression);
  }
}
 
agent SmartBot {
  provider: "openai",
  model: "gpt-4o-mini",
  system: "Use your skills to help users.",
  skills: [Calculator]
}

Guards and Capabilities

Control what tools can do with permission boundaries and validation pipelines:

capability FileAccess {
  pattern: "file:*"
}
 
guard InputValidator {
  description: "Validates input size",
  handlers: [
    on_tool_input(input) -> Bool {
      if (input.length > 10000) { return false; }
      return true;
    }
  ]
}
 
guardchain SecurityChain {
  guards: [InputValidator, OutputSanitizer, RateLimiter]
}
 
tool ReadFile {
  description: "Reads a file from disk",
  capabilities: [FileAccess],
  guards: [InputValidator],
  params: [{ name: "path", type: String }],
  returns: String,
  impl: fun(path) {
    return file_read_string(path);
  }
}

Budget and Resource Management

Enforce cost, time, and token limits on agents:

budget QuickTask {
  time: 5000,       // milliseconds
  cost: 0.10,       // dollars
  tokens: 5000
}
 
agent CheapBot {
  provider: "openai",
  model: "gpt-4o-mini",
  system: "Be brief and efficient.",
  budget: QuickTask
}

Environment Configuration

env Production {
  API_URL: "https://api.prod.com",
  DEBUG: "false",
  API_KEY: env("PROD_API_KEY")
}
 
agent ProdAgent {
  provider: "openai",
  model: "gpt-4o",
  system: "Production agent",
  env: Production
}

Memory, World Model, and Planning

memory ConversationMemory {
  backend: "redis",
  retention: "session",
  max_events: 10000
}
 
world_model TaskWorld {
  tier: 1,
  state_schema: "task_state_v1",
  update_frequency: 1000
}
 
plan HierarchicalPlanner {
  pattern: "hierarchical",
  max_depth: 5,
  backtrack: true,
  pruning: "alpha_beta"
}
 
agent StrategicAgent {
  provider: "openai",
  model: "gpt-4o",
  system: "Think strategically.",
  memory: ConversationMemory,
  world_model: TaskWorld,
  plan: HierarchicalPlanner
}

Subagents and Connectors

subagent Worker {
  base_agent: "MainAgent",
  budget_share: 0.5,
  capability_inherit: true
}
 
connector SlackAPI {
  protocol: "http",
  endpoint: "https://slack.com/api",
  auth: env("SLACK_TOKEN")
}

Built-in Functions

Math (25+)

math_abs(-5);              // 5
math_floor(3.7);           // 3
math_ceil(3.2);            // 4
math_round(3.5);           // 4
math_min(5, 10);           // 5
math_max(5, 10);           // 10
math_clamp(15, 0, 10);     // 10
math_pow(2, 8);            // 256
math_sqrt(16);             // 4
math_sin(angle);           // Trig functions
math_random();             // 0.0 to 1.0
math_random_int(1, 100);   // 1 to 100

JSON

let obj = json_parse('{"name": "Alice"}');
let text = json_stringify(obj);

Time

let now = clock();
let ms = time_now();
time_sleep(1000);
let fmt = time_format(ms, "%Y-%m-%d");

File I/O

let content = file_read_string("./data.txt");
file_write_string("./output.txt", "Hello");
let exists = file_exists("./file.txt");
file_copy("./src.txt", "./dst.txt");

HTTP

let resp = http_get("https://api.example.com/data");
let resp = http_request("POST", "https://api.example.com", body, headers);

Crypto

let hash = crypto_hash("sha256", "data");
let hmac = crypto_hmac("sha256", "secret", "message");
let uuid = crypto_uuid_v4();
let encoded = crypto_base64_encode("hello");

Futures / Async

let resolved = future_resolve(42);
let all = future_all([f1, f2, f3]);
let first = future_race([f1, f2]);
let delayed = future_delay(1000);

Testing

test "addition works" {
  assert_eq(add(2, 3), 5);
}
 
test "string operations" {
  let result = "Hello" + " " + "World";
  assert_eq(result, "Hello World");
}
FunctionDescription
assert_eq(a, b)Assert equality
assert_ne(a, b)Assert inequality
assert_true(cond)Assert truthy
assert_false(cond)Assert falsy
assert_throws(fn)Assert throws

Checkpoint and Rewind

Time-travel debugging for agent workflows:

checkpoint "safe_point";
 
let result = risky_operation();
if (!result) {
  rewind "safe_point";
}

Module System

module my.app.utils;
 
import std.list;
import std.map;
import my.app.config as cfg;
 
pub fun public_helper() { }
fun internal_helper() { }

Cloud Deployment

Neam compiles agents to native binaries and generates deployment artifacts for multiple cloud targets.

Deployment Targets

TargetCommandUse Case
Dockerneam deploy --target dockerLocal / dev containers
Kubernetesneam deploy --target kubernetesProduction clusters
Helmneam deploy --target helmK8s package management
AWS Lambdaneam deploy --target aws-lambdaServerless (AWS)
GCP Cloud Runneam deploy --target gcp-cloudrunServerless containers (GCP)
Azure Functionsneam deploy --target azure-functionsServerless (Azure)
Terraformneam deploy --target terraformInfrastructure as Code

Kubernetes

neam deploy --target kubernetes \
  --replicas 3 \
  --min-replicas 1 \
  --max-replicas 20 \
  --cpu 500m \
  --memory 1Gi \
  --namespace production

Generates deployment.yaml, service.yaml, configmap.yaml, and ingress.yaml in build/deploy/kubernetes/.

AWS Lambda

neam deploy --target aws-lambda --memory 1024 --timeout 30 --arch arm64

GCP Cloud Run

neam deploy --target gcp-cloudrun --region us-central1 --concurrency 80 --cpu-boost

Docker

neam deploy --target docker
docker build -t my-agent -f build/deploy/docker/Dockerfile .
docker run -e OPENAI_API_KEY=$OPENAI_API_KEY my-agent

Generated Artifacts

build/deploy/
  kubernetes/
    deployment.yaml        # Deployment with replicas, resource limits, health probes
    service.yaml           # ClusterIP service
    configmap.yaml         # Environment configuration
    ingress.yaml           # Nginx ingress routing
  cloudrun/
    service.yaml           # GCP Cloud Run Knative service
  aws/
    template.yaml          # AWS SAM template
  helm/
    myapp/                 # Full Helm chart
  docker/
    Dockerfile
    docker-compose.yml
  terraform/
    main.tf

Multi-Cloud Orchestration

Neam routes workloads across AWS, GCP, Azure, and Alibaba Cloud using real-time cost and latency data.

Cost-Aware Routing

The built-in CostAwareRouter automatically selects the cheapest provider:

  1. Polls spot prices across all 4 clouds
  2. Evaluates latency from the current region
  3. Enforces data residency constraints
  4. Routes to the cheapest viable option
  5. Fails over automatically after 3 consecutive errors (60s cooldown)

Routing Constraints

ConstraintDescription
max_latencyMaximum acceptable latency (ms)
max_costMaximum cost per request ($)
preferred_regionsPreferred deployment regions
preferred_providersPreferred cloud providers
data_residencyRequired data residency (e.g., "EU")

Cloud Provider Support

FeatureAWSGCPAzureAlibaba
ServerlessLambdaCloud RunFunctionsFunction Compute
ContainersECS FargateCloud RunContainer AppsECI
VMsEC2Compute EngineVirtual MachinesECS
GPUg4dn / g5 / p4dT4 / L4 / A100NC4 / NC24GN6i / GN6v / GN7i
Managed LLMBedrockVertex AIAzure OpenAIPAI
Spot InstancesYesYesYesYes
KubernetesEKSGKEAKSACK

GPU and SIMD Acceleration

GPU

Automatically accelerates embedding similarity, top-K retrieval, and batch operations when a GPU is available.

BackendPlatform
CUDANVIDIA GPUs
MetalApple Silicon
OpenCLCross-platform
VulkanCross-platform
CPUFallback (always available)
neam deploy --target kubernetes --gpu nvidia-t4 --gpu-memory 16Gi --replicas 2

SIMD

Auto-detected at compile time. 470+ operations accelerated transparently:

ISAWidthPlatform
AVX-512512-bitx86 (Intel/AMD)
AVX2256-bitx86 (Intel/AMD)
SSE4128-bitx86 (Intel/AMD)
NEON128-bitARM (Apple Silicon, Graviton)
SVEScalableARM (server-class)

Accelerated operations: vector dot product, cosine similarity, matrix multiply, ReLU/GELU/Softmax, float32-int8 quantization, substring search, JSON key search, batch normalization, and more.


Auto-Scaling

ML-based predictive scaling with time-series forecasting:

  • Forecast windows: 5 min, 1 hour, 24 hours
  • Pattern detection: daily cycles, weekly cycles, anomaly spikes
  • Warm pool: pre-warmed instances for zero cold-start scale-out
  • Spot optimization: automatic spot vs on-demand switching across clouds
ActionTrigger
Scale upLoad forecast exceeds capacity
Scale downSustained low utilization
Switch to spotSpot price < 70% of on-demand
Switch to on-demandSpot interruption notice
Switch to FaaSBursty, unpredictable traffic

FinOps

Cost Attribution

Real-time cost tracking per agent, task, user, and project across 10 categories: compute, memory, storage, network, LLM API, embedding API, vector DB, state backend, external APIs, and miscellaneous.

budget TeamBudget {
  cost: 500.00,        // $500/day
  tokens: 10000000     // 10M tokens/day
}
 
// Built-in alerts:
//   Warning at 80% consumed
//   Critical at 95% consumed

Dashboard

Real-time monitoring at http://localhost:8080 with 14 widget types: cost over time, cost by category/agent/provider, budget gauges, top spenders, latency/throughput trends, CPU/memory/GPU utilization, error rate, alerts feed, and savings opportunities.

Features: WebSocket live updates, time range presets (1h to 30d), JSON/PDF export, dark mode, embeddable widgets.

Continuous Benchmarking

Automated benchmarks with regression detection for CI/CD:

RegressionThreshold
Latency increase> 10%
Cost increase> 5%
Throughput decrease> 10%

Outputs JUnit XML and GitHub Actions annotations.


Cloud Testing

Run identical agents across all 4 cloud providers to compare performance and cost:

./tests/cloud/run_cloud_tests.sh                        # Full suite
./tests/cloud/run_cloud_tests.sh --provider aws          # Single provider
./tests/cloud/run_cloud_tests.sh --workload latency      # Single workload
./tests/cloud/run_cloud_tests.sh --dry-run               # Validate only

5 pre-configured workloads: latency (1K req), throughput (5K req), cost analysis (100 req), voice pipeline (50 req), GPU workload (200 req).


Complete Examples

RAG Document Assistant

knowledge Docs {
  vector_store: "usearch",
  embedding_model: "nomic-embed-text",
  chunk_size: 200,
  chunk_overlap: 50,
  sources: [
    { type: "file", path: "./docs/guide.md" },
    { type: "file", path: "./docs/faq.md" }
  ],
  retrieval_strategy: "hybrid",
  top_k: 5
}
 
agent DocAssistant {
  provider: "openai",
  model: "gpt-4o",
  system: "Answer questions based on the documentation.",
  connected_knowledge: [Docs]
}
 
let question = input();
let answer = DocAssistant.ask(question);
emit answer;

Multi-Cloud Research System

budget ResearchBudget {
  cost: 25.00,
  tokens: 500000
}
 
agent Planner {
  provider: "bedrock",
  model: "anthropic.claude-3-5-sonnet-20241022-v2:0",
  system: "Decompose research topics into 5 focused sub-questions.",
  budget: ResearchBudget
}
 
agent Researcher {
  provider: "openai",
  model: "gpt-4o",
  system: "Research each question. Provide detailed findings."
}
 
agent Synthesizer {
  provider: "ollama",
  model: "qwen2.5:14b",
  system: "Combine findings into a coherent report."
}
 
let topic = "Impact of quantum computing on cryptography";
let questions = Planner.ask("Create research plan for: " + topic);
let findings = Researcher.ask("Research these questions:\n" + questions);
let report = Synthesizer.ask("Write report from:\n" + findings);
emit report;

Serverless Event Handler

budget ServerlessBudget {
  time: 10000,
  cost: 0.01,
  tokens: 2000
}
 
agent EventHandler {
  provider: "bedrock",
  model: "anthropic.claude-3-5-sonnet-20241022-v2:0",
  system: "Process events concisely. Return structured JSON.",
  budget: ServerlessBudget
}
 
let event = input();
let result = EventHandler.ask("Process this event: " + event);
emit result;
neam deploy --target aws-lambda --memory 512 --timeout 15 --arch arm64

GPU-Accelerated Knowledge Agent

knowledge LargeCorpus {
  vector_store: "usearch",
  embedding_model: "nomic-embed-text",
  chunk_size: 200,
  chunk_overlap: 50,
  sources: [
    { type: "file", path: "./corpus/volume1.md" },
    { type: "file", path: "./corpus/volume2.md" },
    { type: "file", path: "./corpus/volume3.md" }
  ],
  retrieval_strategy: "agentic",
  top_k: 10,
  max_iterations: 5,
  enable_reflection: true
}
 
agent DeepExpert {
  provider: "bedrock",
  model: "anthropic.claude-3-5-sonnet-20241022-v2:0",
  system: "Use all available knowledge to give thorough answers.",
  connected_knowledge: [LargeCorpus]
}
 
let answer = DeepExpert.ask(input());
emit answer;
neam deploy --target kubernetes --gpu nvidia-t4 --gpu-memory 16Gi --replicas 2

Production System with FinOps

budget TeamBudget {
  cost: 500.00,
  tokens: 10000000
}
 
env Monitored {
  FINOPS_DASHBOARD: "true",
  FINOPS_PORT: "8080",
  ALERT_WEBHOOK: env("SLACK_WEBHOOK")
}
 
knowledge InternalDocs {
  vector_store: "usearch",
  embedding_model: "nomic-embed-text",
  chunk_size: 200,
  chunk_overlap: 50,
  sources: [{ type: "file", path: "./docs/" }],
  retrieval_strategy: "mmr",
  top_k: 5,
  mmr_lambda: 0.7
}
 
agent ProductionAgent {
  provider: "openai",
  model: "gpt-4o-mini",
  system: "Production agent with cost tracking.",
  connected_knowledge: [InternalDocs],
  budget: TeamBudget,
  env: Monitored
}
 
let answer = ProductionAgent.ask(input());
emit answer;

v1.1 — NeamOS Foundation (Knowledge, Personas, Governance)

v1.1 adds 7 keywords and 3 agent types for the Enterprise Agentic Operating System:

// Structured organizational knowledge
knowledge_card CustomerChurn {
    type: "concept",
    term: "Customer Churn",
    definition: "No transaction in 90+ days",
    domain: "telecom.retention",
    version: "2.1.0"
}
 
// Curated context per agent per phase
context_assembly ChurnContext {
    target_agent: "DS",
    cards: ["CustomerChurn", "PIIPolicy"],
    max_context_tokens: 4000
}
 
// Declarative enterprise governance
governance_rule PDPA_Retention {
    trigger: "data_write",
    condition: "data.classification == personal_data",
    action: { enforce_ttl: "365d", require_consent: true, audit: "mandatory" },
    regulatory_basis: "PDPA Section 25"
}
 
// Portable ecosystem packaging
blueprint TelecomChurn {
    version: "1.0.0",
    agents: ["ChurnDS", "CausalAgent"],
    knowledge_cards: ["CustomerChurn"]
}

v1.1 Keywords

KeywordPurpose
knowledge_cardStructured organizational knowledge with 4 sub-types (Concept, Policy, Decision, Skill)
context_assemblyMinimum Viable Context curation per agent per phase
agent_personaVoice, avatar, personality traits, multilingual locales
localeInternationalization with compile-time translation checking
governance_ruleDeclarative policy rules with typed trigger conditions
agent_adapterExternal agent interfaces (Claude Code, OpenClaw, etc.)
blueprintPortable ecosystem packages with cross-reference validation

v1.1 Agent Types

AgentPurpose
knowledgeweaver agentKnowledge fabric management and context assembly
adaptagent agentEcosystem monitoring and adaptation proposals
storyteller agentIllustrated narrated stories for education

v1.2 — NeamProd (Plugins, Sessions, Evaluation, Streaming, A2A)

v1.2 makes Neam production-ready with 7 keywords for enterprise infrastructure:

// Plugin system with lifecycle hooks
plugin CostTracker {
    description: "Track LLM costs per agent",
    hooks: { after_model: "observe" },
    scope: "global"
}
 
// Persistent sessions with database backing
session_service ProdSessions {
    backend: "postgresql",
    connection: { host: "db.prod.internal", port: 5432 },
    compression: { strategy: "summarize", token_threshold: 0.8 },
    ttl: "30d"
}
 
// Structured evaluation with CI/CD integration
eval_test ChurnQuality {
    agent: "ChurnDS",
    input: "Predict churn for segment A",
    criteria: ["safety", "hallucination", "trajectory_match"],
    threshold: 0.95
}
 
eval_set ProdGate {
    tests: ["ChurnQuality"],
    judge: { model: "gpt-4o-mini" },
    output_format: "junit"
}
 
// Versioned artifact management
artifact_store Reports {
    backend: "s3",
    path: "s3://neam-prod/artifacts",
    scoping: "user"
}
 
// Real-time streaming
stream_config Live { mode: "sse", event_format: "json" }
 
// Cross-framework interoperability via A2A protocol
a2a_config ChurnService {
    agent_card: { name: "ChurnPredictor", capabilities: ["predict"] },
    expose_as_server: true
}

v1.2 Keywords

KeywordPurpose
pluginLifecycle hooks (before/after agent, model, tool) with observe/intervene/amend modes
session_servicePersistent sessions with 5 backends (inmemory, sqlite, postgresql, redis, dynamodb)
eval_testStructured test cases with trajectory matching and quality metrics
eval_setEvaluation suites with LLM-as-Judge and JUnit XML output for CI/CD
artifact_storeVersioned artifact management with filesystem, S3, GCS, Azure Blob backends
stream_configSSE and bidirectional WebSocket streaming with voice pipeline support
a2a_configA2A protocol configuration — agent cards, peer discovery, server exposure

Version History

VersionCodenameKeywordsAgentsHighlights
v0.6–0.7—20+3Language foundation, agents, skills, RAG, MCP, deployment
v0.8NeamClaw—5Claw agents, Forge agents, sessions, channels
v0.9——1914 data intelligence agents, DIO orchestrator
v1.0NeamOne20+19OWASP ASI01-10 + MCP01-10, cloud stack, evaluation, 3 special agents
v1.1NeamOS Foundation27+22Knowledge cards, personas, governance, blueprints, 3 new agents
v1.2NeamProd34+22Plugins, sessions, evaluation, artifacts, streaming, A2A interop

Environment Variables

VariableDefaultDescription
NEAM_MAX_CALL_DEPTH1000Max recursion depth (1 — 100,000)
NEAM_MAX_REACT_STEPS100Max ReAct loop iterations (1 — 10,000)
NEAM_REPL_HISTORY1000REPL history