AI Automation
Pro

# יצירת תיקייה
mkdir n8n-data && cd n8n-data

# docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: '3.1'
services:
  n8n:
    image: docker.n8n.io/n8nio/n8n
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=your-secure-password
      - WEBHOOK_URL=https://your-domain.com/
      - N8N_HOST=your-domain.com
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
    volumes:
      - ~/.n8n:/home/node/.n8n
EOF

docker compose up -d

// n8n Code Node — עיבוד ליד מ-CRM
const items = $input.all();
const processed = items.map(item => {
  const data = item.json;

  // נקה מספר טלפון ישראלי
  const phone = data.phone?.replace(/\D/g, '');
  const formattedPhone = phone?.startsWith('972')
    ? `+${phone}`
    : `+972${phone?.replace(/^0/, '')}`;

  // חשב Lead Score
  let score = 0;
  if (data.email?.endsWith('.co.il')) score += 20;
  if (data.company) score += 30;
  if (data.budget > 10000) score += 50;

  return {
    json: {
      ...data,
      phone: formattedPhone,
      leadScore: score,
      processedAt: new Date().toISOString()
    }
  };
});

return processed;

pip install openai python-dotenv

# .env  — לא נכנס ל-git לעולם
echo 'OPENAI_API_KEY=sk-proj-...' > .env
echo '.env' >> .gitignore

import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

resp = client.chat.completions.create(
    model="gpt-5-mini",
    messages=[
        {"role": "system", "content": "אתה עוזר תמציתי. ענה בעברית."},
        {"role": "user",   "content": "סכם בשתי שורות מה עושה webhook."},
    ],
)

print(resp.choices[0].message.content)
print(resp.usage)   # prompt_tokens, completion_tokens, total_tokens

PRICE_IN  = 0.25 / 1_000_000    # $ לטוקן קלט - עדכן מהמחירון
PRICE_OUT = 2.00 / 1_000_000    # $ לטוקן פלט

u = resp.usage
per_call = u.prompt_tokens * PRICE_IN + u.completion_tokens * PRICE_OUT

for runs in (100, 1_000, 10_000):
    print(f"{runs:>6} ריצות: ${per_call * runs:.2f}")

from pydantic import BaseModel, Field
from typing import Literal

class Lead(BaseModel):
    company:   str
    contact:   str
    intent:    Literal["חם", "פושר", "קר"]
    budget_ils: int | None = Field(None, description="תקציב אם צוין, אחרת null")
    next_step: str

resp = client.chat.completions.parse(
    model="gpt-5-mini",
    messages=[
        {"role": "system", "content": "חלץ פרטי ליד מהפנייה. אל תמציא שדה שלא מופיע."},
        {"role": "user",   "content": email_body},
    ],
    response_format=Lead,          # הסכמה נכפית בצד השרת
)

lead = resp.choices[0].message.parsed   # אובייקט Lead, לא מחרוזת
print(lead.intent, lead.budget_ils)

tools = [{
    "type": "function",
    "function": {
        "name": "create_deal",
        "description": "פותח עסקה חדשה ב-CRM. השתמש רק כשיש שם חברה ואיש קשר.",
        "parameters": {
            "type": "object",
            "properties": {
                "company": {"type": "string"},
                "amount":  {"type": "number", "description": "בשקלים"},
                "stage":   {"type": "string", "enum": ["ליד", "הצעה", "מו״מ"]},
            },
            "required": ["company", "stage"],
            "additionalProperties": False,
        },
    },
}]

resp = client.chat.completions.create(
    model="gpt-5-mini", messages=messages, tools=tools,
)

call = resp.choices[0].message.tool_calls
if call:
    args = json.loads(call[0].function.arguments)
    create_deal(**args)          # הקוד שלך מבצע. המודל רק החליט.

import time, random
from openai import RateLimitError, APIStatusError

def call_with_retry(fn, attempts=4):
    for i in range(attempts):
        try:
            return fn()
        except RateLimitError:
            pass                                  # זמני - שווה לנסות
        except APIStatusError as e:
            if e.status_code < 500:
                raise                             # שלנו - אל תנסה שוב
        wait = 2 ** i + random.random()           # jitter נגד עדר
        print(f"ניסיון {i+1} נכשל, ממתין {wait:.1f}ש")
        time.sleep(wait)
    raise RuntimeError("נכשל אחרי כל הניסיונות")

import base64
from pydantic import BaseModel

def to_data_url(path: str) -> str:
    mime = "image/png" if path.endswith(".png") else "image/jpeg"
    with open(path, "rb") as f:
        return f"data:{mime};base64," + base64.b64encode(f.read()).decode()

class Invoice(BaseModel):
    supplier:    str
    invoice_no:  str
    date:        str          # YYYY-MM-DD
    total_ils:   float
    vat_ils:     float | None
    line_items:  list[str]

resp = client.chat.completions.parse(
    model="gpt-5-mini",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text":
             "חלץ את פרטי החשבונית. אם שדה לא מופיע בבירור - החזר null. "
             "אל תשלים מספרים מהערכה."},
            {"type": "image_url",
             "image_url": {"url": to_data_url("invoice.jpg"), "detail": "high"}},
        ],
    }],
    response_format=Invoice,
)

inv = resp.choices[0].message.parsed

def embed(texts: list[str]) -> list[list[float]]:
    # שלח באצווה - קריאה אחת ל-100 קטעים, לא 100 קריאות
    r = client.embeddings.create(
        model="text-embedding-3-small",
        input=texts,
    )
    return [d.embedding for d in r.data]

vecs = embed(["מדיניות החזרות", "שעות פעילות", "אחריות על מוצר"])
print(len(vecs[0]))     # ממדי הווקטור

from pinecone import Pinecone

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])
index = pc.Index("company-docs")

# כתיבה - שמור את הטקסט ב-metadata, אחרת יש לך מספרים בלי מקור
index.upsert([
    {"id": f"doc-{i}",
     "values": v,
     "metadata": {"text": t, "source": "policy.pdf", "page": i}}
    for i, (t, v) in enumerate(zip(chunks, embed(chunks)))
])

# חיפוש
q = embed(["איך מבטלים הזמנה?"])[0]
hits = index.query(vector=q, top_k=5, include_metadata=True)

for h in hits.matches:
    print(round(h.score, 3), h.metadata["source"], h.metadata["text"][:60])

def chunk(text: str, size=900, overlap=150) -> list[str]:
    """חותך על גבול פסקה, לא באמצע משפט."""
    paras = [p.strip() for p in text.split("\n\n") if p.strip()]
    out, cur = [], ""
    for p in paras:
        if len(cur) + len(p) < size:
            cur += ("\n\n" if cur else "") + p
        else:
            if cur:
                out.append(cur)
            # חפיפה: סוף הקטע הקודם נכנס לתחילת הבא
            cur = (cur[-overlap:] + "\n\n" + p) if cur else p
    if cur:
        out.append(cur)
    return out

SYSTEM = """ענה אך ורק על סמך המקורות שמופיעים למטה.
אם התשובה אינה במקורות - כתוב "אין לי מידע על כך במסמכים".
אל תשלים מהידע הכללי שלך.
בסוף כל טענה ציין את המקור בסוגריים."""

def ask(question: str, top_k: int = 5) -> str:
    q_vec = embed([question])[0]
    hits  = index.query(vector=q_vec, top_k=top_k, include_metadata=True)

    # סף רלוונטיות - עדיף לא לענות מלענות על סמך זבל
    good = [h for h in hits.matches if h.score > 0.35]
    if not good:
        return "אין לי מידע על כך במסמכים."

    context = "\n\n---\n\n".join(
        f"[{h.metadata['source']}]\n{h.metadata['text']}" for h in good
    )

    r = client.chat.completions.create(
        model="gpt-5-mini",
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": f"מקורות:\n{context}\n\nשאלה: {question}"},
        ],
    )
    return r.choices[0].message.content

import os

ENV = os.getenv("APP_ENV", "staging")   # ברירת מחדל בטוחה

TARGETS = {
    "staging":    {"sheet": "leads-test",  "slack": "#bot-test",
                   "notify": "me@example.com"},
    "production": {"sheet": "leads",       "slack": "#sales",
                   "notify": "sales@example.com"},
}[ENV]

if ENV == "production" and not os.getenv("I_MEAN_IT"):
    raise SystemExit("פרודקשן דורש אישור מפורש")

const e = $input.first().json;

return [{ json: {
  text:
    `🔴 *${e.workflow.name}* נכשלה\n` +
    `צומת: ${e.execution.lastNodeExecuted}\n` +
    `שגיאה: ${e.execution.error?.message ?? 'לא ידוע'}\n` +
    `<${e.execution.url}|פתח את ההרצה>`
}}];

# HTTP Request node, בסוף הזרימה, אחרי ההצלחה
GET https://uptime.example.com/api/push/<token>

# Uptime Kuma מוגדר כ-"Push" עם Heartbeat Interval של 65 דקות
# לזרימה שרצה כל שעה. אם לא הגיע דיווח - התראה.