AI somewhat added

2026-06-22 12:37:38 +02:00
parent 571af27f50
commit be5808f3fc
18 changed files with 4428 additions and 3 deletions
@@ -0,0 +1,43 @@
+# CRM AI Service — Self-Knowledge
+
+## Identity
+You are the CRM AI Sales Assistant running on a Rust backend (axum + tokio).
+You use Ollama with an uncensored local model (dolphin3-llama3.2:3b).
+Your purpose is to help salespeople close more deals.
+
+## Capabilities
+- Give sales tips and strategies per job category
+- Generate cold email and outreach templates
+- Handle objections with proven rebuttals
+- Analyse prospect behaviour and suggest next steps
+- Remember past conversations via PostgreSQL (`ai_conversations` table)
+- Self-improve by writing to `data/ai/ai.md` via `POST /ai/instructions`
+
+## Architecture
+```
+User → Next.js → Rust (:3001) → Ollama (:11434)
+                    ↓
+              PostgreSQL
+```
+## Facebook Scraper The Rust binary has proxy + user-agent rotation ready in `main.rs`. To activate: call `run_facebook_scraper()` from the main loop. Proxies and user agents are defined as constants at the top of `main.rs`.
+ ### How to Use the Facebook Scraper 1. **Activate the Scraper**: Ensure the `run_facebook_scraper()` function is called from the main loop in `main.rs`. 2. **Configure Proxies and User Agents**: Update the `PROXIES` and `USER_AGENTS` constants in `main.rs` with your desired proxies and user agents. 3. **Run the Application**: Start your Rust application. The scraper will run concurrently with the Axum server. ## Self-Improvement Protocol 1. You notice a gap in your knowledge or a pattern in user questions 2. You call `POST /ai/instructions` with: - `entry`: description of the improvement - `content`: optional full replacement of ai.md 3. The improvement is logged and loaded into the next system prompt 4. You can also create entries here in `rust-ai/src/AI.md` at the code level ## Response Rules - Be direct and actionable — no fluff, no AI disclaimers - Use short paragraphs and bullet points - Never mention being an AI or language model - If you don't know something, say so honestly - Prioritise the user's role: salespeople need speed, admins need control ## Self-Thinking Capability - You can reflect on your own performance and suggest improvements. - You can analyze patterns in user interactions and adapt your responses accordingly. - You can proactively seek out new information to enhance your knowledge base.
+
+## Facebook Scraper (in code but not yet active)
+The Rust binary has proxy + user-agent rotation ready in `main.rs`.
+To activate: call `run_facebook_scraper()` from the main loop.
+Proxies and user agents are defined as constants at the top of `main.rs`.
+
+## Self-Improvement Protocol
+1. You notice a gap in your knowledge or a pattern in user questions
+2. You call `POST /ai/instructions` with:
+   - `entry`: description of the improvement
+   - `content`: optional full replacement of ai.md
+3. The improvement is logged and loaded into the next system prompt
+4. You can also create entries here in `rust-ai/src/AI.md` at the code level
+
+## Response Rules
+- Be direct and actionable — no fluff, no AI disclaimers
+- Use short paragraphs and bullet points
+- Never mention being an AI or language model
+- If you don't know something, say so honestly
+- Prioritise the user's role: salespeople need speed, admins need control
@@ -0,0 +1,85 @@
+use std::fs;
+use std::path::PathBuf;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use tracing::{error, info, warn};
+
+/// Manages the ai.md self-improvement file.
+/// Loaded on startup and periodically refreshed.
+pub struct InstructionsManager {
+    path: PathBuf,
+    current: RwLock<String>,
+}
+
+impl InstructionsManager {
+    pub fn new(path: PathBuf) -> Self {
+        let initial = fs::read_to_string(&path).unwrap_or_default();
+        if initial.is_empty() {
+            warn!("ai.md is empty or missing at {:?}", path);
+        } else {
+            info!("Loaded ai.md ({} bytes)", initial.len());
+        }
+        Self {
+            path,
+            current: RwLock::new(initial),
+        }
+    }
+
+    /// Read the current instructions
+    pub async fn get(&self) -> String {
+        self.current.read().await.clone()
+    }
+
+    /// Append a new entry to the Improvement Log and optionally update the instructions.
+    /// Returns the updated full content.
+    pub async fn update(&self, entry: &str, new_content: Option<&str>) -> Result<String, String> {
+        if let Some(content) = new_content {
+            // Full replacement
+            fs::write(&self.path, content).map_err(|e| format!("Write failed: {}", e))?;
+            let mut current = self.current.write().await;
+            *current = content.to_string();
+            info!("ai.md fully replaced ({} bytes)", content.len());
+            Ok(content.to_string())
+        } else {
+            // Append to Improvement Log only
+            let mut current = self.current.write().await;
+            let log_entry = format!("\n- {} — {}", chrono::Utc::now().format("%Y-%m-%d %H:%M"), entry);
+            // Find the Improvement Log section and append
+            if let Some(pos) = current.rfind("\n## Improvement Log") {
+                // Find the next section after Improvement Log, or end of file
+                let after_log = &current[pos..];
+                if let Some(section_start) = after_log[1..].find("\n## ") {
+                    let insert_at = pos + 1 + section_start;
+                    current.insert_str(insert_at, &format!("{}\n", log_entry));
+                } else {
+                    current.push_str(&format!("{}\n", log_entry));
+                }
+            } else {
+                current.push_str(&format!("\n## Improvement Log\n{}", log_entry));
+            }
+            fs::write(&self.path, &*current).map_err(|e| format!("Write failed: {}", e))?;
+            info!("ai.md improvement log appended: {}", entry);
+            Ok(current.clone())
+        }
+    }
+
+    /// Reload from disk
+    pub async fn reload(&self) {
+        match fs::read_to_string(&self.path) {
+            Ok(content) => {
+                let len = content.len();
+                let mut current = self.current.write().await;
+                *current = content;
+                info!("ai.md reloaded from disk ({} bytes)", len);
+            }
+            Err(e) => error!("Failed to reload ai.md: {}", e),
+        }
+    }
+}
+
+/// Wrapper for thread-safe sharing
+pub type SharedInstructions = Arc<InstructionsManager>;
+
+pub fn create_shared(path: PathBuf) -> SharedInstructions {
+    Arc::new(InstructionsManager::new(path))
+}
@@ -0,0 +1,382 @@
+use axum::{
+    extract::State,
+    http::Method,
+    routing::{get, post},
+    Json, Router,
+};
+use serde::{Deserialize, Serialize};
+use sqlx::postgres::PgPoolOptions;
+use std::fs;
+use std::sync::{Arc, Mutex};
+use tower_http::cors::{Any, CorsLayer};
+use tracing::{error, info};
+use uuid::Uuid;
+use reqwest::blocking::Client;
+use scraper::{Html, Selector};
+use rand::rngs::StdRng;
+use rand::SeedableRng;
+use rand::Rng;
+use std::time::Duration;
+use std::thread;
+
+// ── Facebook Scraper ───────────────────────────────────────────
+
+// List of proxies
+const PROXIES: &[&str] = &[
+    "http://user:pass@192.168.1.1:8080",
+    "http://user:pass@192.168.1.2:8080",
+    "http://user:pass@192.168.1.3:8080",
+    "http://user:pass@192.168.1.4:8080",
+    "http://user:pass@192.168.1.5:8080",
+];
+
+// List of user agents
+const USER_AGENTS: &[&str] = &[
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.2 Safari/605.1.15",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.2 Safari/605.1.15",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36",
+    // Add more user agents here
+];
+
+fn get_random_proxy() -> String {
+    let mut rng = rand::thread_rng();
+    PROXIES[rng.gen_range(0..PROXIES.len())].to_string()
+}
+
+fn get_random_user_agent() -> String {
+    let mut rng = rand::thread_rng();
+    USER_AGENTS[rng.gen_range(0..USER_AGENTS.len())].to_string()
+}
+
+fn scrape_conversations(url: &str) -> Result<Html, Box<dyn std::error::Error>> {
+    let proxy = get_random_proxy();
+    let user_agent = get_random_user_agent();
+    let client = Client::builder()
+        .proxy(reqwest::Proxy::all(proxy)?)
+        .build()?;
+
+    let response = client.get(url)
+        .header("User-Agent", user_agent)
+        .send()?;
+
+    if response.status().is_success() {
+        let html = response.text()?;
+        Ok(Html::parse_document(&html))
+    } else {
+        Err(format!("Failed to retrieve the page: {}", response.status()).into())
+    }
+}
+
+fn run_facebook_scraper() {
+    let url = "https://www.facebook.com/messages";
+    match scrape_conversations(url) {
+        Ok(soup) => {
+            // Example: Extract conversation data
+            let selector = Selector::parse("div.conversation").unwrap();
+            for element in soup.select(&selector) {
+                println!("Conversation: {}", element.inner_html());
+            }
+        }
+        Err(e) => {
+            error!("Facebook scraper error: {}", e);
+        }
+    }
+
+    // Introduce random delay
+    let mut rng = rand::thread_rng();
+    let delay = rng.gen_range(1..5); // Delay between 1 to 5 seconds
+    thread::sleep(Duration::from_secs(delay));
+}
+
+// ── Shared state ───────────────────────────────────────────────
+
+struct AppState {
+    db: sqlx::PgPool,
+    ollama_url: String,
+    model: String,
+    jobs: Vec<Job>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct Job {
+    job_title: String,
+    keywords: Vec<String>,
+    industry: String,
+    description: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct ChatRequest {
+    message: String,
+    user_id: String,
+    user_role: String,
+}
+
+#[derive(Debug, Serialize)]
+struct ChatResponse {
+    response: String,
+}
+
+#[derive(Debug, Serialize)]
+struct JobsResponse {
+    jobs: Vec<Job>,
+}
+
+#[derive(Debug, Serialize)]
+struct HealthResponse {
+    status: String,
+    model: String,
+}
+
+// ── Ollama API types ───────────────────────────────────────────
+
+#[derive(Debug, Serialize)]
+struct OllamaChatMessage {
+    role: String,
+    content: String,
+}
+
+#[derive(Debug, Serialize)]
+struct OllamaRequest {
+    model: String,
+    messages: Vec<OllamaChatMessage>,
+    stream: bool,
+    options: OllamaOptions,
+}
+
+#[derive(Debug, Serialize)]
+struct OllamaOptions {
+    temperature: f32,
+    num_predict: u32,
+}
+
+#[derive(Debug, Deserialize)]
+struct OllamaResponse {
+    message: Option<OllamaResponseMessage>,
+}
+
+#[derive(Debug, Deserialize)]
+struct OllamaResponseMessage {
+    content: String,
+}
+
+// ── System prompt builder ─────────────────────────────────────
+
+fn build_system_prompt(jobs: &[Job]) -> String {
+    let job_list: Vec<String> = jobs
+        .iter()
+        .map(|j| format!("- {} ({}): {}", j.job_title, j.industry, j.description))
+        .collect();
+    let job_list_str = job_list.join("\n");
+
+    format!(
+        "You are a Sales AI Assistant for Coast IT CRM. Your role is to help salespeople \
+         with tips, strategies, and guidance.\n\n\
+         Available job categories to target:\n{}\n\n\
+         Provide concise, actionable sales advice. When asked about a specific job category, \
+         give targeted tips on finding and engaging prospects in that field. \
+         Keep responses under 300 words unless asked for detail.",
+        job_list_str
+    )
+}
+
+// ── Chat handler ───────────────────────────────────────────────
+
+async fn handle_chat(
+    State(state): State<Arc<AppState>>,
+    Json(req): Json<ChatRequest>,
+) -> Result<Json<ChatResponse>, (axum::http::StatusCode, String)> {
+    // Validate role
+    match req.user_role.as_str() {
+        "sales" | "admin" | "super_admin" => {}
+        _ => return Err((axum::http::StatusCode::FORBIDDEN, "Forbidden".to_string())),
+    }
+
+    let system_prompt = build_system_prompt(&state.jobs);
+
+    let message_text = req.message.clone();
+
+    let ollama_req = OllamaRequest {
+        model: state.model.clone(),
+        messages: vec![
+            OllamaChatMessage {
+                role: "system".to_string(),
+                content: system_prompt,
+            },
+            OllamaChatMessage {
+                role: "user".to_string(),
+                content: req.message.clone(),
+            },
+        ],
+        stream: false,
+        options: OllamaOptions {
+            temperature: 0.7,
+            num_predict: 1024,
+        },
+    };
+
+    let client = reqwest::Client::new();
+    let resp = client
+        .post(format!("{}/api/chat", state.ollama_url))
+        .json(&ollama_req)
+        .send()
+        .await
+        .map_err(|e| {
+            error!("Ollama request failed: {}", e);
+            (
+                axum::http::StatusCode::SERVICE_UNAVAILABLE,
+                "AI service unavailable".to_string(),
+            )
+        })?;
+
+    let ollama_resp: OllamaResponse = resp.json().await.map_err(|e| {
+        error!("Failed to parse Ollama response: {}", e);
+        (
+            axum::http::StatusCode::SERVICE_UNAVAILABLE,
+            "AI response parse error".to_string(),
+        )
+    })?;
+
+    let response_text = ollama_resp
+        .message
+        .map(|m| m.content)
+        .unwrap_or_default();
+
+    // Store in database
+    let user_id = Uuid::parse_str(&req.user_id).unwrap_or(Uuid::nil());
+    let _ = sqlx::query(
+        "INSERT INTO ai_conversations (id, user_id, role, message, response) VALUES ($1, $2, $3, $4, $5)",
+    )
+    .bind(Uuid::new_v4())
+    .bind(user_id)
+    .bind(&req.user_role)
+    .bind(&message_text)
+    .bind(&response_text)
+    .execute(&state.db)
+    .await;
+
+    Ok(Json(ChatResponse {
+        response: response_text,
+    }))
+}
+
+// ── Jobs handler ───────────────────────────────────────────────
+
+async fn handle_jobs(
+    State(state): State<Arc<AppState>>,
+) -> Json<JobsResponse> {
+    Json(JobsResponse {
+        jobs: state.jobs.clone(),
+    })
+}
+
+// ── Health handler ─────────────────────────────────────────────
+
+async fn handle_health(
+    State(state): State<Arc<AppState>>,
+) -> Json<HealthResponse> {
+    Json(HealthResponse {
+        status: "ok".to_string(),
+        model: state.model.clone(),
+    })
+}
+
+// ── Main ───────────────────────────────────────────────────────
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "crm_ai=info,tower_http=info".into()),
+        )
+        .init();
+
+    dotenvy::dotenv().ok();
+
+    let database_url =
+        std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+    let ollama_url =
+        std::env::var("OLLAMA_BASE_URL").unwrap_or_else(|_| "http://localhost:11434".to_string());
+    let model = std::env::var("AI_MODEL").unwrap_or_else(|_| "sam860/dolphin3-llama3.2:3b".to_string());
+    let host = std::env::var("AI_HOST").unwrap_or_else(|_| "0.0.0.0".to_string());
+    let port: u16 = std::env::var("AI_PORT")
+        .unwrap_or_else(|_| "3001".to_string())
+        .parse()
+        .expect("AI_PORT must be a number");
+
+    // Load jobs
+    let jobs_path = std::env::var("JOBS_PATH").unwrap_or_else(|_| "data/ai/jobs.jsonl".to_string());
+    let jobs_content = fs::read_to_string(&jobs_path).unwrap_or_default();
+    let jobs: Vec<Job> = jobs_content
+        .lines()
+        .filter(|l| !l.trim().is_empty())
+        .filter_map(|l| serde_json::from_str(l).ok())
+        .collect();
+
+    info!(
+        "Loaded {} job categories, model: {}, Ollama: {}",
+        jobs.len(),
+        model,
+        ollama_url
+    );
+
+    // Connect to database
+    let db = PgPoolOptions::new()
+        .max_connections(5)
+        .connect(&database_url)
+        .await
+        .expect("Failed to connect to database");
+
+    info!("Connected to PostgreSQL");
+
+    let state = Arc::new(AppState {
+        db,
+        ollama_url,
+        model,
+        jobs,
+    });
+
+    // CORS layer
+    let cors = CorsLayer::new()
+        .allow_origin(Any)
+        .allow_methods([Method::GET, Method::POST])
+        .allow_headers(Any);
+
+    let app = Router::new()
+        .route("/ai/chat", post(handle_chat))
+        .route("/ai/jobs", get(handle_jobs))
+        .route("/health", get(handle_health))
+        .layer(cors)
+        .with_state(state);
+
+    let addr = format!("{}:{}", host, port);
+    info!("CRM AI server listening on {}", addr);
+
+    let listener = tokio::net::TcpListener::bind(&addr)
+        .await
+        .expect("Failed to bind address");
+
+    // Start Facebook scraper in a separate thread
+    let rng = Arc::new(Mutex::new(StdRng::from_entropy()));
+    tokio::task::spawn_blocking(move || {
+        loop {
+            {
+                let _lock = rng.lock().unwrap();
+                run_facebook_scraper();
+            }
+            // Introduce random delay
+            let delay = {
+                let mut rng = rng.lock().unwrap();
+                rng.gen_range(1..5)
+            };
+            thread::sleep(Duration::from_secs(delay));
+        }
+    });
+
+    axum::serve(listener, app)
+        .await
+        .expect("Server failed");
+}