Upload 52 files

__init__.py

@@ -0,0 +1,2 @@
+"""AI Business Process Automation Agent package."""
+

agents/__init__.py

@@ -0,0 +1,2 @@
+"""Agent implementations."""
+

agents/decision_agent.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Dict
+
+from langchain_core.messages import HumanMessage
+
+from ai_business_automation_agent.prompts.decision_prompt import DECISION_PROMPT
+from ai_business_automation_agent.utils import append_agent_log, parse_llm_json
+
+logger = logging.getLogger(__name__)
+
+
+def run_decision_agent(state: Dict[str, Any], llm) -> Dict[str, Any]:
+    validation = state.get("validation_status") or {}
+    vendor_ver = state.get("vendor_verification") or {}
+
+    prompt = DECISION_PROMPT.format(
+        validation_json=json.dumps(validation, ensure_ascii=False),
+        vendor_verification_json=json.dumps(vendor_ver, ensure_ascii=False),
+    )
+    resp = llm.invoke([HumanMessage(content=prompt)])
+    text = getattr(resp, "content", str(resp))
+    parsed, err = parse_llm_json(text)
+
+    updates: Dict[str, Any] = {}
+    if err:
+        logger.warning("Decision JSON parse error: %s", err)
+        updates["decision"] = {
+            "decision": "manual_review",
+            "reason": f"Parsing failed: {err}",
+            "routing": {"requires_human_review": True, "queue": "ap"},
+            "raw_model_output": text,
+        }
+        updates.update(append_agent_log(state, agent="decision", event="error", payload={"error": err}))
+    else:
+        updates["decision"] = parsed
+        updates.update(append_agent_log(state, agent="decision", event="ok", payload=parsed))
+
+    updates.update(append_agent_log(state, agent="decision", event="prompt", payload={"prompt": prompt}))
+    updates.update(append_agent_log(state, agent="decision", event="raw_response", payload={"text": text}))
+    return updates
+
+
+def decision_route(state: Dict[str, Any]) -> str:
+    decision = (state.get("decision") or {}).get("decision")
+    if decision == "approved":
+        return "approved"
+    if decision == "manual_review":
+        return "manual_review"
+    return "rejected"
+

agents/extraction_agent.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Dict
+
+from langchain_core.messages import HumanMessage
+
+from ai_business_automation_agent.prompts.extraction_prompt import EXTRACTION_PROMPT
+from ai_business_automation_agent.utils import append_agent_log, parse_llm_json
+
+logger = logging.getLogger(__name__)
+
+
+def run_extraction_agent(state: Dict[str, Any], llm) -> Dict[str, Any]:
+    email_content = state.get("email_content", "")
+    prompt = EXTRACTION_PROMPT.format(email_content=email_content)
+
+    msg = HumanMessage(content=prompt)
+    resp = llm.invoke([msg])
+    text = getattr(resp, "content", str(resp))
+
+    parsed, err = parse_llm_json(text)
+    updates: Dict[str, Any] = {}
+    if err:
+        logger.warning("Extraction JSON parse error: %s", err)
+        updates["extracted_data"] = {
+            "invoice": {},
+            "vendor": {},
+            "extraction_confidence": "low",
+            "notes": f"Parsing failed: {err}",
+            "raw_model_output": text,
+        }
+        updates.update(append_agent_log(state, agent="extraction", event="error", payload={"error": err}))
+    else:
+        updates["extracted_data"] = parsed
+        updates.update(append_agent_log(state, agent="extraction", event="ok", payload=parsed))
+
+    updates.update(append_agent_log(state, agent="extraction", event="prompt", payload={"prompt": prompt}))
+    updates.update(append_agent_log(state, agent="extraction", event="raw_response", payload={"text": text}))
+    return updates
+
+
+def compact_extracted_summary(extracted: Dict[str, Any]) -> str:
+    try:
+        invoice = extracted.get("invoice", {})
+        vendor = extracted.get("vendor", {})
+        return json.dumps(
+            {
+                "invoice_number": invoice.get("invoice_number"),
+                "invoice_date": invoice.get("invoice_date"),
+                "total": invoice.get("total"),
+                "currency": invoice.get("currency"),
+                "vendor_name": vendor.get("name"),
+                "vendor_website": vendor.get("website"),
+            },
+            ensure_ascii=False,
+        )
+    except Exception:
+        return "{}"
+

agents/reporting_agent.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Dict
+
+from langchain_core.messages import HumanMessage
+
+from ai_business_automation_agent.prompts.reporting_prompt import REPORTING_PROMPT
+from ai_business_automation_agent.utils import append_agent_log, parse_llm_json
+
+logger = logging.getLogger(__name__)
+
+
+def run_reporting_agent(state: Dict[str, Any], llm) -> Dict[str, Any]:
+    prompt = REPORTING_PROMPT.format(
+        email_content=state.get("email_content", ""),
+        extracted_json=json.dumps(state.get("extracted_data") or {}, ensure_ascii=False),
+        vendor_verification_json=json.dumps(state.get("vendor_verification") or {}, ensure_ascii=False),
+        validation_json=json.dumps(state.get("validation_status") or {}, ensure_ascii=False),
+        decision_json=json.dumps(state.get("decision") or {}, ensure_ascii=False),
+        erp_json=json.dumps(state.get("erp_update_status") or {}, ensure_ascii=False),
+    )
+    resp = llm.invoke([HumanMessage(content=prompt)])
+    text = getattr(resp, "content", str(resp))
+    parsed, err = parse_llm_json(text)
+
+    updates: Dict[str, Any] = {}
+    if err:
+        logger.warning("Reporting JSON parse error: %s", err)
+        updates["report"] = (
+            "REPORT GENERATION FAILED\n\n"
+            f"Error: {err}\n\n"
+            "Raw model output:\n"
+            f"{text}"
+        )
+        updates.update(append_agent_log(state, agent="reporting", event="error", payload={"error": err}))
+    else:
+        updates["report"] = parsed.get("report", "")
+        updates.update(append_agent_log(state, agent="reporting", event="ok", payload=parsed))
+
+    updates.update(append_agent_log(state, agent="reporting", event="prompt", payload={"prompt": prompt}))
+    updates.update(append_agent_log(state, agent="reporting", event="raw_response", payload={"text": text}))
+    return updates
+

agents/validation_agent.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+from typing import Any, Dict, List
+
+from langchain_core.messages import HumanMessage
+
+from ai_business_automation_agent.prompts.validation_prompt import VALIDATION_PROMPT
+from ai_business_automation_agent.utils import append_agent_log, parse_llm_json
+from ai_business_automation_agent.vectorstore.pinecone_client import PineconeVectorStore
+
+logger = logging.getLogger(__name__)
+
+
+def _format_policy_context(chunks: List[Dict[str, Any]]) -> str:
+    if not chunks:
+        return "No policy context available."
+    lines = []
+    for c in chunks:
+        score = c.get("score")
+        text = (c.get("text") or "").strip()
+        if text:
+            lines.append(f"- (score={score}) {text}")
+    return "\n".join(lines).strip() or "No policy context available."
+
+
+def run_validation_agent(state: Dict[str, Any], llm) -> Dict[str, Any]:
+    extracted = state.get("extracted_data") or {}
+    vendor_ver = state.get("vendor_verification") or {}
+
+    policy_context = "No policy context available."
+    try:
+        vs = PineconeVectorStore(namespace="policies")
+        if os.getenv("SEED_VECTORSTORE", "true").lower() in {"1", "true", "yes"}:
+            vs.seed_default_policies()
+        query = json.dumps(
+            {
+                "invoice": extracted.get("invoice", {}),
+                "vendor": extracted.get("vendor", {}),
+                "vendor_verification": vendor_ver,
+            },
+            ensure_ascii=False,
+        )
+        chunks = vs.retrieve(query, top_k=5)
+        policy_context = _format_policy_context(chunks)
+        rag_payload = {"retrieved": chunks}
+    except Exception as e:
+        logger.warning("Pinecone retrieval unavailable: %s", e)
+        rag_payload = {"error": str(e)}
+
+    prompt = VALIDATION_PROMPT.format(
+        extracted_json=json.dumps(extracted, ensure_ascii=False),
+        vendor_verification_json=json.dumps(vendor_ver, ensure_ascii=False),
+        policy_context=policy_context,
+    )
+    resp = llm.invoke([HumanMessage(content=prompt)])
+    text = getattr(resp, "content", str(resp))
+    parsed, err = parse_llm_json(text)
+
+    updates: Dict[str, Any] = {}
+    if err:
+        logger.warning("Validation JSON parse error: %s", err)
+        updates["validation_status"] = {
+            "status": "needs_review",
+            "issues": [{"code": "PARSING_ERROR", "severity": "high", "message": err}],
+            "compliance_flags": [],
+            "validated_fields": {},
+            "recommendation": "manual_review",
+            "raw_model_output": text,
+            "rag": rag_payload,
+        }
+        updates.update(append_agent_log(state, agent="validation", event="error", payload={"error": err}))
+    else:
+        parsed["rag"] = rag_payload
+        updates["validation_status"] = parsed
+        updates.update(append_agent_log(state, agent="validation", event="ok", payload=parsed))
+
+    updates.update(append_agent_log(state, agent="validation", event="rag", payload=rag_payload))
+    updates.update(append_agent_log(state, agent="validation", event="prompt", payload={"prompt": prompt}))
+    updates.update(append_agent_log(state, agent="validation", event="raw_response", payload={"text": text}))
+    return updates
+

agents/vendor_verification_agent.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Dict, Optional
+
+from langchain_core.messages import HumanMessage
+
+from ai_business_automation_agent.prompts.vendor_prompt import VENDOR_VERIFICATION_PROMPT
+from ai_business_automation_agent.tools.web_search_tool import TavilyWebSearchTool
+from ai_business_automation_agent.utils import append_agent_log, parse_llm_json
+
+logger = logging.getLogger(__name__)
+
+
+def run_vendor_verification_agent(
+    state: Dict[str, Any], llm, web_search: Optional[TavilyWebSearchTool]
+) -> Dict[str, Any]:
+    extracted = state.get("extracted_data") or {}
+    vendor = extracted.get("vendor") or {}
+    vendor_name = vendor.get("name") or "unknown vendor"
+
+    query = f"{vendor_name} company legitimacy business registration"
+    if web_search is None:
+        web_summary = "Tavily not configured; no web verification performed."
+    else:
+        search_raw = web_search.search(query=query, max_results=5)
+        web_summary = web_search.summarize(search_raw)
+
+    prompt = VENDOR_VERIFICATION_PROMPT.format(
+        vendor_json=json.dumps(vendor, ensure_ascii=False),
+        web_summary=web_summary,
+    )
+    resp = llm.invoke([HumanMessage(content=prompt)])
+    text = getattr(resp, "content", str(resp))
+    parsed, err = parse_llm_json(text)
+
+    updates: Dict[str, Any] = {}
+    if err:
+        logger.warning("Vendor verification JSON parse error: %s", err)
+        updates["vendor_verification"] = {
+            "status": "flagged",
+            "risk_score": 5,
+            "reason": f"Parsing failed: {err}",
+            "evidence_summary": "Vendor verification could not be reliably parsed; defaulting to manual review.",
+            "recommended_action": "manual_review",
+            "raw_model_output": text,
+            "web_search": {"query": query, "summary": web_summary},
+        }
+        updates.update(append_agent_log(state, agent="vendor_verification", event="error", payload={"error": err}))
+    else:
+        parsed["web_search"] = {"query": query, "summary": web_summary}
+        updates["vendor_verification"] = parsed
+        updates.update(append_agent_log(state, agent="vendor_verification", event="ok", payload=parsed))
+
+    updates.update(append_agent_log(state, agent="vendor_verification", event="prompt", payload={"prompt": prompt}))
+    updates.update(append_agent_log(state, agent="vendor_verification", event="raw_response", payload={"text": text}))
+    return updates
+

app.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+# When running `streamlit run ai_business_automation_agent/app.py`, Python's sys.path
+# may not include the project root, so absolute package imports can fail.
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from ai_business_automation_agent.ui.streamlit_dashboard import main
+
+
+if __name__ == "__main__":
+    main()
+

embeddings/__init__.py

@@ -0,0 +1,2 @@
+"""Embedding model utilities."""
+

embeddings/embedding_model.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import logging
+from functools import lru_cache
+from typing import List
+
+from sentence_transformers import SentenceTransformer
+
+logger = logging.getLogger(__name__)
+
+
+@lru_cache(maxsize=1)
+def get_embedding_model(model_name: str = "sentence-transformers/all-MiniLM-L6-v2") -> SentenceTransformer:
+    """
+    Return a cached SentenceTransformers model instance.
+
+    Note: loading the model can be slow; caching keeps Streamlit responsive.
+    """
+
+    logger.info("Loading embedding model: %s", model_name)
+    return SentenceTransformer(model_name)
+
+
+def embed_texts(texts: List[str], model_name: str = "sentence-transformers/all-MiniLM-L6-v2") -> List[List[float]]:
+    model = get_embedding_model(model_name=model_name)
+    vectors = model.encode(texts, normalize_embeddings=True)
+    return [v.tolist() for v in vectors]
+

llm.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import os
+from functools import lru_cache
+from langchain_groq import ChatGroq
+
+
+@lru_cache(maxsize=1)
+def get_groq_llm(model: str = "llama-3.3-70b-versatile", temperature: float = 0.0) -> ChatGroq:
+    api_key = os.getenv("GROQ_API_KEY", "")
+    if not api_key:
+        raise ValueError("Missing GROQ_API_KEY.")
+    return ChatGroq(model=model, temperature=temperature, api_key=api_key)
+

prompts/__init__.py

@@ -0,0 +1,2 @@
+"""Prompt templates for agents."""
+

prompts/decision_prompt.py

@@ -0,0 +1,44 @@
+DECISION_PROMPT = """\
+SYSTEM ROLE
+You are the enterprise Financial Decision Agent.
+
+OBJECTIVE
+Determine whether an invoice should be approved, rejected, or sent for manual review.
+
+CONTEXT
+The decision should be deterministic and auditable.
+
+INSTRUCTIONS
+- Output MUST be strict JSON (no markdown, no extra text).
+- Use these deterministic decision rules:
+
+DECISION RULES
+- APPROVED:
+  - validation_status.status == "pass"
+  - vendor_verification.status == "verified"
+- MANUAL_REVIEW:
+  - vendor_verification.status == "flagged"
+  - OR validation_status.status == "needs_review"
+  - OR vendor evidence is insufficient/ambiguous
+- REJECTED:
+  - vendor_verification.status == "suspicious"
+  - OR validation_status.status == "fail"
+
+INPUT
+validation_status:
+{validation_json}
+
+vendor_verification:
+{vendor_verification_json}
+
+OUTPUT FORMAT (STRICT JSON)
+{{
+  "decision": "approved|manual_review|rejected",
+  "reason": "string",
+  "routing": {{
+    "requires_human_review": true,
+    "queue": "ap|compliance|vendor_management|none"
+  }}
+}}
+"""
+

prompts/extraction_prompt.py

@@ -0,0 +1,53 @@
+EXTRACTION_PROMPT = """\
+SYSTEM ROLE
+You are an enterprise-grade Invoice Data Extraction Agent.
+
+OBJECTIVE
+Extract structured invoice fields from unstructured business email or invoice text.
+
+CONTEXT
+The user provides the full email body and/or invoice text. You must extract fields reliably and conservatively.
+
+INSTRUCTIONS
+- Output MUST be strict JSON (no markdown, no extra text).
+- If a field is missing, set it to null.
+- Do not hallucinate addresses, tax IDs, or totals.
+- Normalize dates to ISO 8601 if possible (YYYY-MM-DD). Otherwise null.
+- Currency should be a 3-letter code when known (e.g., USD, EUR, INR), otherwise null.
+
+INPUT
+{email_content}
+
+OUTPUT FORMAT (STRICT JSON)
+{{
+  "invoice": {{
+    "invoice_number": "string|null",
+    "invoice_date": "YYYY-MM-DD|null",
+    "due_date": "YYYY-MM-DD|null",
+    "currency": "string|null",
+    "subtotal": "number|null",
+    "tax": "number|null",
+    "total": "number|null",
+    "purchase_order_number": "string|null",
+    "line_items": [
+      {{
+        "description": "string|null",
+        "quantity": "number|null",
+        "unit_price": "number|null",
+        "amount": "number|null"
+      }}
+    ]
+  }},
+  "vendor": {{
+    "name": "string|null",
+    "email": "string|null",
+    "phone": "string|null",
+    "address": "string|null",
+    "website": "string|null",
+    "tax_id": "string|null"
+  }},
+  "extraction_confidence": "low|medium|high",
+  "notes": "string"
+}}
+"""
+

prompts/reporting_prompt.py

@@ -0,0 +1,40 @@
+REPORTING_PROMPT = """\
+SYSTEM ROLE
+You are an enterprise Reporting Agent.
+
+OBJECTIVE
+Generate a professional, executive-ready report of the invoice processing outcome.
+
+CONTEXT
+The report will be shown in a dashboard and stored for audit.
+
+INSTRUCTIONS
+- Output MUST be strict JSON (no markdown, no extra text).
+- Keep it concise, clear, and business-friendly.
+- Include a short "Next steps" section.
+
+INPUT
+email_content:
+{email_content}
+
+extracted_data:
+{extracted_json}
+
+vendor_verification:
+{vendor_verification_json}
+
+validation_status:
+{validation_json}
+
+decision:
+{decision_json}
+
+erp_update_status:
+{erp_json}
+
+OUTPUT FORMAT (STRICT JSON)
+{{
+  "report": "string"
+}}
+"""
+

prompts/validation_prompt.py

@@ -0,0 +1,57 @@
+VALIDATION_PROMPT = """\
+SYSTEM ROLE
+You are an enterprise Invoice Validation & Compliance Agent.
+
+OBJECTIVE
+Validate extracted invoice fields against business rules and compliance policies.
+
+CONTEXT
+You will receive:
+- extracted invoice data
+- vendor verification result
+- retrieved policy/compliance context (RAG)
+
+INSTRUCTIONS
+- Output MUST be strict JSON (no markdown, no extra text).
+- Apply the provided policy context. If a rule isn't mentioned, do not invent it.
+- Validate: presence of key fields, total consistency (subtotal + tax ≈ total), and vendor risk.
+- If totals are present, allow small rounding tolerance up to 0.02.
+- Vendor risk interpretation:
+  - vendor_verification.status == "verified": proceed normally
+  - "flagged": bias towards needs_review unless everything else is clean
+  - "suspicious": bias towards fail unless policy context explicitly allows proceeding
+
+INPUT
+extracted_data:
+{extracted_json}
+
+vendor_verification:
+{vendor_verification_json}
+
+policy_context:
+{policy_context}
+
+OUTPUT FORMAT (STRICT JSON)
+{{
+  "status": "pass|fail|needs_review",
+  "issues": [
+    {{
+      "code": "string",
+      "severity": "low|medium|high",
+      "message": "string"
+    }}
+  ],
+  "compliance_flags": [
+    "string"
+  ],
+  "validated_fields": {{
+    "invoice_number_present": true,
+    "invoice_date_present": false,
+    "vendor_name_present": true,
+    "total_present": true,
+    "total_consistency": "ok|mismatch|unknown"
+  }},
+  "recommendation": "approve|reject|manual_review"
+}}
+"""
+

prompts/vendor_prompt.py

@@ -0,0 +1,39 @@
+VENDOR_VERIFICATION_PROMPT = """\
+SYSTEM ROLE
+You are an enterprise Vendor Verification Agent.
+
+OBJECTIVE
+Assess vendor legitimacy using third-party search evidence and the extracted vendor identity.
+
+CONTEXT
+You will be provided:
+- extracted vendor fields (may be incomplete)
+- a summarized web search result set
+
+INSTRUCTIONS
+- Output MUST be strict JSON (no markdown, no extra text).
+- Base your assessment on evidence in the search summary.
+- Company names may appear in different but equivalent formats. Treat these as matches:
+  - capitalization differences (NetCore vs netcore)
+  - abbreviations (Pvt Ltd ≈ Private Limited, Inc ≈ Incorporated, LLC)
+  - punctuation differences and minor spacing
+- Only mark a vendor as suspicious when there is clear negative evidence (scam/fraud reports, blacklists, fake registration).
+- If evidence is insufficient, mark status as "flagged" (manual review) and explain what is missing.
+
+INPUT
+vendor:
+{vendor_json}
+
+web_search_summary:
+{web_summary}
+
+OUTPUT FORMAT (STRICT JSON)
+{{
+  "status": "verified|flagged|suspicious",
+  "risk_score": 1,
+  "reason": "short explanation",
+  "evidence_summary": "string",
+  "recommended_action": "proceed|manual_review|block"
+}}
+"""
+

tools/__init__.py

@@ -0,0 +1,2 @@
+"""External tools used by agents."""
+

tools/erp_tool.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def simulate_erp_update(extracted_data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Simulate an ERP update.
+
+    In production, replace with a real ERP connector (SAP/Oracle/Dynamics) and robust idempotency keys.
+    """
+
+    invoice = (extracted_data or {}).get("invoice", {}) if isinstance(extracted_data, dict) else {}
+    vendor = (extracted_data or {}).get("vendor", {}) if isinstance(extracted_data, dict) else {}
+    invoice_number = invoice.get("invoice_number")
+    vendor_name = vendor.get("name")
+
+    logger.info("Simulating ERP update for invoice=%s vendor=%s", invoice_number, vendor_name)
+    return {
+        "status": "updated",
+        "erp_reference_id": f"ERP-SIM-{invoice_number or 'UNKNOWN'}",
+        "message": "ERP update simulated successfully.",
+    }
+

tools/web_search_tool.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+from tavily import TavilyClient
+
+logger = logging.getLogger(__name__)
+
+
+class TavilyWebSearchTool:
+    def __init__(self, api_key: Optional[str] = None) -> None:
+        api_key = api_key or os.getenv("TAVILY_API_KEY", "")
+        if not api_key:
+            raise ValueError("Missing TAVILY_API_KEY.")
+        self._client = TavilyClient(api_key=api_key)
+
+    def search(self, query: str, *, max_results: int = 5) -> Dict[str, Any]:
+        logger.info("Tavily search: %s", query)
+        res = self._client.search(query=query, max_results=max_results)
+        return res
+
+    @staticmethod
+    def summarize(search_result: Dict[str, Any]) -> str:
+        results: List[Dict[str, Any]] = search_result.get("results", []) or []
+        lines = []
+        for r in results[:8]:
+            title = r.get("title") or ""
+            url = r.get("url") or ""
+            content = (r.get("content") or "").strip()
+            if len(content) > 400:
+                content = content[:400] + "..."
+            lines.append(f"- {title} ({url})\n  {content}")
+        return "\n".join(lines).strip() or "No results."
+

ui/__init__.py

@@ -0,0 +1,2 @@
+"""Streamlit UI."""
+

ui/streamlit_dashboard.py

@@ -0,0 +1,413 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+from typing import Any, Dict, Optional
+
+import streamlit as st
+
+from ai_business_automation_agent.utils import load_environment, setup_logging
+from ai_business_automation_agent.workflow.graph_builder import run_workflow
+
+logger = logging.getLogger(__name__)
+
+
+def _read_uploaded_text(upload) -> Optional[str]:
+    if upload is None:
+        return None
+    raw = upload.read()
+    if not raw:
+        return None
+    try:
+        return raw.decode("utf-8")
+    except Exception:
+        try:
+            return raw.decode("latin-1")
+        except Exception:
+            return None
+
+
+def _status_badge(label: str, status: str) -> None:
+    color = {
+        "ok": "green",
+        "pass": "green",
+        "approved": "green",
+        "updated": "green",
+        "needs_review": "orange",
+        "unknown": "orange",
+        "flagged": "orange",
+        "manual_review": "orange",
+        "suspicious": "red",
+        "fail": "red",
+        "rejected": "red",
+        "failed": "red",
+    }.get(status, "gray")
+    st.markdown(
+        f"""
+<div class="status-badge">
+  <span class="status-dot" style="background:{color};"></span>
+  <span class="status-label">{label}</span>
+  <span class="status-text">({status})</span>
+</div>
+""",
+        unsafe_allow_html=True,
+    )
+
+
+def _render_pipeline_timeline(
+    extracted: Dict[str, Any],
+    vendor_ver: Dict[str, Any],
+    validation: Dict[str, Any],
+    decision: Dict[str, Any],
+    erp: Dict[str, Any],
+) -> None:
+    """Render a horizontal stepper for the LangGraph pipeline."""
+
+    def step_state(is_done: bool, is_current: bool) -> str:
+        if is_current:
+            return "current"
+        return "done" if is_done else "pending"
+
+    steps = [
+        ("Extraction", bool(extracted)),
+        ("Vendor", bool(vendor_ver)),
+        ("Validation", bool(validation)),
+        ("Decision", bool(decision)),
+        ("ERP/Report", bool(erp) or bool(decision)),
+    ]
+
+    # Determine current step: first not-done, otherwise last.
+    current_idx = 0
+    for i, (_, done) in enumerate(steps):
+        if not done:
+            current_idx = i
+            break
+    else:
+        current_idx = len(steps) - 1
+
+    items = []
+    for idx, (label, done) in enumerate(steps):
+        state = step_state(done, idx == current_idx)
+        items.append(f'<div class="step step-{state}"><div class="step-dot"></div><div class="step-label">{label}</div></div>')
+        if idx < len(steps) - 1:
+            items.append('<div class="step-connector"></div>')
+
+    html = '<div class="pipeline-timeline">' + "".join(items) + "</div>"
+    st.markdown(html, unsafe_allow_html=True)
+
+
+def main() -> None:
+    load_environment()
+    setup_logging()
+
+    st.set_page_config(page_title="AI Business Process Automation Agent", layout="wide")
+
+    # Global lightweight styling
+    st.markdown(
+        """
+<style>
+/* App background + typography */
+.stApp {{
+  background: radial-gradient(circle at top, #1f2937 0, #020617 42%, #020617 100%);
+  color: #e5e7eb;
+}}
+
+/* Center container width */
+.block-container {{
+  max-width: 1180px;
+  padding-top: 1.2rem;
+}}
+
+/* Status badges */
+.status-badge {{
+  display: flex;
+  gap: 0.4rem;
+  align-items: center;
+  margin: 0.2rem 0 0.6rem 0;
+  font-size: 0.86rem;
+}}
+.status-dot {{
+  width: 10px;
+  height: 10px;
+  border-radius: 999px;
+  display: inline-block;
+}}
+.status-label {{
+  font-weight: 600;
+}}
+.status-text {{
+  color: #9ca3af;
+}}
+
+/* Card look */
+.card {{
+  background: radial-gradient(circle at top left, rgba(56,189,248,0.12), rgba(15,23,42,0.98));
+  border-radius: 0.9rem;
+  border: 1px solid rgba(56,189,248,0.45);
+  padding: 1rem 1.2rem;
+  box-shadow: 0 24px 65px rgba(15,23,42,0.95);
+}}
+.card-soft {{
+  background: #020617;
+  border-radius: 0.9rem;
+  border: 1px solid #1f2937;
+  padding: 1rem 1.2rem;
+}}
+
+/* Tabs */
+.stTabs [data-baseweb="tab-list"] {{
+  gap: 0.5rem;
+}}
+.stTabs [data-baseweb="tab"] {{
+  padding: 0.45rem 0.9rem;
+  border-radius: 999px;
+  background: #020617;
+  color: #e5e7eb;
+}}
+.stTabs [aria-selected="true"] {{
+  background: #1e293b !important;
+  border: 1px solid #38bdf8 !important;
+}}
+
+/* Metric tweaks */
+div[data-testid="stMetric"] {{
+  background: #020617;
+  border-radius: 0.9rem;
+  border: 1px solid #1f2937;
+  padding: 0.6rem 0.6rem 0.2rem 0.6rem;
+}}
+
+/* Text areas */
+textarea{{background: #020617 !important; color: #e5e7eb !important;}}
+
+/* Pipeline timeline */
+.pipeline-timeline {{
+  display: flex;
+  align-items: center;
+  gap: 0.45rem;
+  margin-top: 0.4rem;
+  padding: 0.45rem 0.6rem 0.2rem;
+}}
+.step {{
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 0.15rem;
+  font-size: 0.78rem;
+}}
+.step-dot {{
+  width: 12px;
+  height: 12px;
+  border-radius: 999px;
+  border: 2px solid #4b5563;
+  background: #020617;
+}}
+.step-label {{
+  color: #e5e7eb;
+}}
+.step-connector {{
+  flex: 1;
+  height: 2px;
+  background: linear-gradient(90deg, #1f2937, #4b5563, #1f2937);
+  opacity: 0.7;
+}}
+.step-done .step-dot {{
+  background: #22c55e;
+  border-color: #22c55e;
+}}
+.step-current .step-dot {{
+  background: #38bdf8;
+  border-color: #38bdf8;
+  box-shadow: 0 0 0 4px rgba(56,189,248,0.25);
+}}
+.step-current .step-label {{
+  color: #e5e7eb;
+  font-weight: 600;
+}}
+.step-pending .step-dot {{
+  background: #020617;
+  border-color: #4b5563;
+}}
+.step-pending .step-label {{
+  color: #9ca3af;
+}}
+
+</style>
+""",
+        unsafe_allow_html=True,
+    )
+
+    # Hero header
+    st.markdown(
+        """
+<div style="display:flex;justify-content:space-between;align-items:flex-start;gap:1.5rem;margin-bottom:0.8rem;">
+  <div>
+    <div style="font-size:0.78rem;font-weight:600;color:#38bdf8;letter-spacing:0.18em;text-transform:uppercase;margin-bottom:0.45rem;">
+      AI BUSINESS PROCESS AUTOMATION
+    </div>
+    <div style="font-size:1.7rem;font-weight:650;color:#f9fafb;margin-bottom:0.35rem;">
+      Invoice & Vendor Workflow Orchestration
+    </div>
+    <div style="font-size:0.9rem;color:#9ca3af;max-width:36rem;">
+      Multi-agent pipeline powered by LangGraph, Groq, Tavily, and Pinecone to extract, validate,
+      and route business invoices like an enterprise workflow engine.
+    </div>
+  </div>
+  <div style="text-align:right;font-size:0.78rem;color:#9ca3af;">
+    <div style="font-weight:600;color:#e5e7eb;margin-bottom:0.15rem;">Stack</div>
+    <div>LangGraph · LangChain</div>
+    <div>Groq llama-3.3-70b-versatile</div>
+    <div>Tavily · Pinecone · Streamlit</div>
+  </div>
+</div>
+""",
+        unsafe_allow_html=True,
+    )
+
+    with st.sidebar:
+        st.markdown("### Configuration")
+        st.caption("Keys are kept in memory for this session only.")
+
+        groq_key = st.text_input("GROQ_API_KEY", type="password", help="Required to run agents.")
+        tavily_key = st.text_input("TAVILY_API_KEY", type="password", help="Optional (vendor verification).")
+        pinecone_key = st.text_input("PINECONE_API_KEY", type="password", help="Optional (policy RAG).")
+
+        if groq_key.strip():
+            os.environ["GROQ_API_KEY"] = groq_key.strip()
+        if tavily_key.strip():
+            os.environ["TAVILY_API_KEY"] = tavily_key.strip()
+        if pinecone_key.strip():
+            os.environ["PINECONE_API_KEY"] = pinecone_key.strip()
+
+        st.markdown("---")
+        st.markdown("### Input")
+        upload = st.file_uploader("Upload email/invoice text (.txt)", type=["txt"])
+        uploaded_text = _read_uploaded_text(upload)
+
+        default_example = """Subject: Invoice INV-10492 - ACME Supplies
+
+Hello Accounts Payable,
+
+Please find below invoice details:
+- Vendor: ACME Supplies Ltd
+- Invoice Number: INV-10492
+- Invoice Date: 2026-03-10
+- Due Date: 2026-04-09
+- Currency: USD
+- Subtotal: 1200.00
+- Tax: 96.00
+- Total: 1296.00
+
+Line items:
+1) Office chairs (qty 4) @ 300.00 = 1200.00
+
+Regards,
+ACME Billing
+billing@acmesupplies.example
+"""
+
+        email_content = st.text_area(
+            "Paste email / invoice content",
+            value=uploaded_text or default_example,
+            height=280,
+        )
+        run_clicked = st.button("Run automation workflow", type="primary", use_container_width=True)
+
+    if run_clicked:
+        if not email_content.strip():
+            st.error("Please provide invoice/email text.")
+            st.stop()
+
+        with st.spinner("Running multi-agent workflow..."):
+            try:
+                result = run_workflow(email_content=email_content)
+                st.session_state["last_result"] = result
+            except Exception as e:
+                logger.exception("Workflow failed")
+                st.error(f"Workflow failed: {e}")
+                st.stop()
+
+    result: Dict[str, Any] = st.session_state.get("last_result") or {}
+
+    extracted = result.get("extracted_data") or {}
+    vendor_ver = result.get("vendor_verification") or {}
+    validation = result.get("validation_status") or {}
+    decision = result.get("decision") or {}
+    erp = result.get("erp_update_status") or {}
+
+    # Top decision summary card
+    with st.container():
+        col_a, col_b, col_c = st.columns([1.2, 1, 1], gap="medium")
+        with col_a:
+            st.markdown("#### Decision overview")
+            with st.container():
+                st.metric("Final decision", decision.get("decision", "unknown"))
+                reason = decision.get("reason") or "Run the workflow to see a decision."
+                st.markdown(
+                    f"<div style='font-size:0.9rem;color:#cbd5f5;margin-top:0.35rem;'>{reason}</div>",
+                    unsafe_allow_html=True,
+                )
+        with col_b:
+            st.markdown("#### Validation")
+            _status_badge("Validation", validation.get("status", "unknown"))
+            st.caption(f"Recommendation: {validation.get('recommendation', 'n/a')}")
+        with col_c:
+            st.markdown("#### Vendor risk")
+            _status_badge("Vendor", vendor_ver.get("status", "unknown"))
+            st.caption(vendor_ver.get("reason", vendor_ver.get("evidence_summary", "No vendor assessment yet.")))
+
+    # Visual pipeline timeline
+    _render_pipeline_timeline(extracted, vendor_ver, validation, decision, erp)
+
+    st.markdown("")  # spacer
+
+    # Main content tabs
+    tabs = st.tabs(["🧠 Agents", "📄 Report", "📊 Logs & JSON"])
+
+    with tabs[0]:
+        st.markdown("### Agent pipeline outputs")
+
+        col1, col2 = st.columns([0.6, 0.4], gap="large")
+        with col1:
+            st.markdown("##### Extraction & Vendor")
+            with st.expander("1) Extraction Agent", expanded=True):
+                _status_badge("Extraction", (extracted.get("extraction_confidence") or "unknown"))
+                st.json(extracted)
+
+            with st.expander("2) Vendor Verification Agent", expanded=True):
+                _status_badge("Vendor verification", (vendor_ver.get("status") or "unknown"))
+                st.json(vendor_ver)
+
+        with col2:
+            st.markdown("##### Validation, Decision & ERP")
+            with st.expander("3) Validation Agent", expanded=True):
+                _status_badge("Validation", (validation.get("status") or "unknown"))
+                st.json(validation)
+
+            with st.expander("4) Decision Agent", expanded=True):
+                _status_badge("Decision", (decision.get("decision") or "unknown"))
+                st.json(decision)
+
+            with st.expander("5) ERP Update Tool", expanded=True):
+                _status_badge("ERP update", (erp.get("status") or "unknown"))
+                st.json(erp)
+
+    with tabs[1]:
+        st.markdown("### Generated business report")
+        report = result.get("report") or ""
+        if report:
+            st.text_area("Report", value=report, height=420)
+        else:
+            st.info("Run the workflow to generate a report.")
+
+    with tabs[2]:
+        st.markdown("### Agent logs (audit trail)")
+        logs = result.get("agent_logs") or []
+        if logs:
+            st.dataframe(logs, use_container_width=True, hide_index=True)
+            with st.expander("Raw result JSON"):
+                st.code(json.dumps(result, indent=2, ensure_ascii=False))
+        else:
+            st.caption("Logs will appear after running the workflow.")
+

utils.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional, Tuple
+
+from dotenv import load_dotenv
+
+
+def load_environment() -> None:
+    """Load environment variables from a local .env if present."""
+
+    # Prefer the project-local .env at ai_business_automation_agent/.env.
+    # This avoids surprises when Streamlit's working directory differs.
+    project_env = Path(__file__).resolve().parent / ".env"
+    # Use override=True to ensure .env values replace empty process env vars.
+    if project_env.exists():
+        load_dotenv(dotenv_path=project_env, override=True)
+    else:
+        load_dotenv(override=True)
+
+
+def setup_logging() -> None:
+    level = os.getenv("LOG_LEVEL", "INFO").upper().strip()
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+    )
+
+
+def utc_now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _extract_first_json_object(text: str) -> Optional[str]:
+    """Best-effort extraction of first top-level JSON object from text."""
+
+    start = text.find("{")
+    if start == -1:
+        return None
+    depth = 0
+    for i in range(start, len(text)):
+        ch = text[i]
+        if ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+            if depth == 0:
+                return text[start : i + 1]
+    return None
+
+
+def parse_llm_json(text: str) -> Tuple[Dict[str, Any], Optional[str]]:
+    """
+    Parse strict JSON from an LLM response.
+
+    Returns (obj, error). If parsing fails, obj will be {}, error will be a message.
+    """
+
+    raw = text.strip()
+    try:
+        return json.loads(raw), None
+    except Exception:
+        candidate = _extract_first_json_object(raw)
+        if not candidate:
+            return {}, "No JSON object found in model output."
+        try:
+            return json.loads(candidate), None
+        except Exception as e:
+            return {}, f"Failed to parse JSON: {e}"
+
+
+def append_agent_log(state: Dict[str, Any], *, agent: str, event: str, payload: Any) -> Dict[str, Any]:
+    logs = list(state.get("agent_logs") or [])
+    logs.append(
+        {
+            "ts": utc_now_iso(),
+            "agent": agent,
+            "event": event,
+            "payload": payload,
+        }
+    )
+    return {"agent_logs": logs}
+

vectorstore/__init__.py

@@ -0,0 +1,2 @@
+"""Vector store integrations (Pinecone)."""
+

vectorstore/pinecone_client.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+from ai_business_automation_agent.embeddings.embedding_model import embed_texts
+
+logger = logging.getLogger(__name__)
+
+
+class PineconeVectorStore:
+    """
+    Minimal Pinecone wrapper for policy/compliance retrieval.
+
+    Supports both:
+    - pinecone-client (legacy) import style: import pinecone
+    - newer pinecone SDK import style: from pinecone import Pinecone
+    """
+
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        index_name: Optional[str] = None,
+        cloud: Optional[str] = None,
+        region: Optional[str] = None,
+        namespace: str = "policies",
+    ) -> None:
+        self.api_key = api_key or os.getenv("PINECONE_API_KEY", "")
+        self.index_name = index_name or os.getenv("PINECONE_INDEX_NAME", "ai-bpa-agent")
+        self.cloud = cloud or os.getenv("PINECONE_CLOUD", "aws")
+        self.region = region or os.getenv("PINECONE_REGION", "us-east-1")
+        self.namespace = namespace
+
+        if not self.api_key:
+            raise ValueError("Missing PINECONE_API_KEY.")
+
+        self._index = self._init_index()
+
+    def _init_index(self):
+        # Newer SDK
+        try:
+            from pinecone import Pinecone  # type: ignore
+
+            pc = Pinecone(api_key=self.api_key)
+            # list_indexes shape varies by pinecone SDK version
+            raw = pc.list_indexes()  # type: ignore[call-arg]
+            existing: set[str] = set()
+            if isinstance(raw, dict):
+                for i in raw.get("indexes", []) or []:
+                    if isinstance(i, dict) and i.get("name"):
+                        existing.add(str(i["name"]))
+            elif isinstance(raw, list):
+                for i in raw:
+                    if isinstance(i, str):
+                        existing.add(i)
+                    else:
+                        name = getattr(i, "name", None)
+                        if name:
+                            existing.add(str(name))
+            else:
+                # Some versions return an object with `.indexes`
+                indexes = getattr(raw, "indexes", None)
+                if isinstance(indexes, list):
+                    for i in indexes:
+                        if isinstance(i, dict) and i.get("name"):
+                            existing.add(str(i["name"]))
+                        else:
+                            name = getattr(i, "name", None)
+                            if name:
+                                existing.add(str(name))
+            if self.index_name not in existing:
+                logger.info("Creating Pinecone index '%s' (cloud=%s region=%s)", self.index_name, self.cloud, self.region)
+                pc.create_index(
+                    name=self.index_name,
+                    dimension=384,
+                    metric="cosine",
+                    spec={"serverless": {"cloud": self.cloud, "region": self.region}},
+                )
+            return pc.Index(self.index_name)
+        except Exception:
+            pass
+
+        # Legacy pinecone-client
+        import pinecone  # type: ignore
+
+        pinecone.init(api_key=self.api_key, environment=os.getenv("PINECONE_ENVIRONMENT", ""))
+        if self.index_name not in pinecone.list_indexes():
+            logger.info("Creating Pinecone index '%s' (legacy)", self.index_name)
+            pinecone.create_index(self.index_name, dimension=384, metric="cosine")
+        return pinecone.Index(self.index_name)
+
+    def seed_default_policies(self) -> None:
+        """
+        Idempotently seed a small set of example policy/rule documents.
+        In production, replace this with your real corp policies and compliance corpus.
+        """
+
+        docs = [
+            (
+                "policy-1",
+                "Invoices must include invoice number, invoice date, vendor name, and total amount.",
+                {"type": "policy", "topic": "required_fields"},
+            ),
+            (
+                "policy-2",
+                "If vendor is flagged or unknown, route invoice to manual review or reject based on risk severity.",
+                {"type": "policy", "topic": "vendor_risk"},
+            ),
+            (
+                "rule-1",
+                "Reject invoices where subtotal + tax differs from total by more than 0.02 (rounding tolerance).",
+                {"type": "rule", "topic": "totals_consistency"},
+            ),
+            (
+                "rule-2",
+                "For high-severity compliance issues (e.g., missing total, missing invoice number), reject the invoice.",
+                {"type": "rule", "topic": "compliance"},
+            ),
+        ]
+
+        texts = [d[1] for d in docs]
+        vectors = embed_texts(texts)
+        upserts = []
+        for (doc_id, text, meta), vec in zip(docs, vectors):
+            upserts.append({"id": doc_id, "values": vec, "metadata": {"text": text, **meta}})
+
+        self._index.upsert(vectors=upserts, namespace=self.namespace)
+
+    def retrieve(self, query: str, *, top_k: int = 5) -> List[Dict[str, Any]]:
+        vec = embed_texts([query])[0]
+        res = self._index.query(vector=vec, top_k=top_k, include_metadata=True, namespace=self.namespace)
+        matches = res.get("matches", []) if isinstance(res, dict) else getattr(res, "matches", [])
+        out: List[Dict[str, Any]] = []
+        for m in matches:
+            md = m.get("metadata", {}) if isinstance(m, dict) else getattr(m, "metadata", {})  # type: ignore
+            score = m.get("score") if isinstance(m, dict) else getattr(m, "score", None)  # type: ignore
+            out.append({"score": score, "text": md.get("text"), "metadata": md})
+        return out
+

workflow/__init__.py

@@ -0,0 +1,2 @@
+"""LangGraph workflow components."""
+