version: '3.8'

services:
  flowwise:
    image: flowwiseai/flowwise:1.6.6
    container_name: flowwise_orchestrator
    restart: always

    ports:
      - "3000:3000"

    environment:
      - PORT=3000
      - DATABASE_PATH=/root/.flowwise
      - APIKEY_PATH=/root/.flowwise
      - SECRETKEY_PATH=/root/.flowwise
      - LOG_LEVEL=debug

    volumes:
      - ./flowwise_data:/root/.flowwise

import requests

FLOWWISE_API_URL = (
    "http://localhost:3000/api/v1/prediction/YOUR-CHATFLOW-ID"
)

def query_ai_pipeline(
    user_message: str,
    user_session_id: str
) -> dict:

    payload = {
        "question": user_message,
        "overrideConfig": {
            "sessionId": user_session_id,
            "returnOption": True
        }
    }

    headers = {
        "Content-Type": "application/json"
    }

    response = requests.post(
        FLOWWISE_API_URL,
        json=payload,
        headers=headers
    )

    if response.status_code == 200:
        return response.json()

    raise Exception(
        f"API Hatası [{response.status_code}]: "
        f"{response.text}"
    )

result = query_ai_pipeline(
    "Ankara'da bugün hava nasıl?",
    user_session_id="usr_123_sess_99"
)

print(result)

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([
    (
        "system",
        "Sen kıdemli bir yazılım mimarısın. "
        "Soruları teknik detaylarıyla yanıtla."
    ),
    ("user", "{question}")
])

model = ChatAnthropic(
    model="claude-3-5-sonnet-20240620",
    temperature=0.2,
    max_tokens=2048
)

parser = StrOutputParser()

chain = prompt | model | parser

# async response
# response = await chain.ainvoke({
#     "question": "LCEL'in avantajları nelerdir?"
# })

from langchain_community.chat_message_histories \
    import Neo4jChatMessageHistory

def get_neo4j_memory(session_id: str):
    return Neo4jChatMessageHistory(
        session_id=session_id,
        url="bolt://localhost:7687",
        username="neo4j",
        password="your_password"
    )

memory = get_neo4j_memory(
    "usr_volkan_sess_01"
)

memory.add_user_message(
    "Ben Volkan, Python geliştiricisiyim."
)

memory.add_ai_message(
    "Merhaba Volkan! Python projelerinde "
    "nasıl yardımcı olabilirim?"
)

import chainlit as cl
from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

@cl.on_chat_start
async def on_chat_start():
    prompt = ChatPromptTemplate.from_messages([
        ("system", "Sen yardımcı bir AI asistanısın."),
        ("user", "{question}")
    ])

    model = ChatAnthropic(
        model="claude-3-5-sonnet-20240620",
        streaming=True
    )

    chain = prompt | model | StrOutputParser()

    cl.user_session.set("chain", chain)

    await cl.Message(
        content="Sisteme hoş geldiniz!"
    ).send()

@cl.on_message
async def on_message(message: cl.Message):
    chain = cl.user_session.get("chain")

    msg = cl.Message(content="")
    await msg.send()

    async for chunk in chain.astream({
        "question": message.content
    }):
        await msg.stream_token(chunk)

    await msg.update()

import chainlit as cl

@cl.password_auth_callback
def auth_callback(
    username: str,
    password: str
):
    # Production'da password hash kontrolü yapılmalıdır.
    if username == "admin" and password == "secure_password_123":
        return cl.User(
            identifier=username,
            metadata={
                "role": "admin",
                "provider": "credentials"
            }
        )

    return None

from chainlit.data.sql_alchemy \
    import SQLAlchemyDataLayer
import chainlit as cl

DATABASE_URL = (
    "postgresql+asyncpg://"
    "postgres:admin_password@"
    "localhost:5432/chainlit_db"
)

@cl.data_layer
def setup_data_layer():
    return SQLAlchemyDataLayer(
        conninfo=DATABASE_URL
    )

import chainlit as cl

@cl.step(
    type="tool",
    name="Translator Step"
)
async def translate_to_english(
    text: str
) -> str:
    translated = f"[Translated]: {text}"
    return translated

from langchain_text_splitters import \
    RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len,
    is_separator_regex=False,
    separators=[
        "\n\n",
        "\n",
        " ",
        ""
    ]
)

import hashlib
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import OllamaEmbeddings
from langchain_core.documents import Document

embedding_model = OllamaEmbeddings(
    model="bge-m3:latest",
    base_url="http://localhost:11434"
)

vector_store = Chroma(
    collection_name="enterprise_knowledge",
    embedding_function=embedding_model,
    persist_directory="./chroma_db_storage"
)

def add_documents_with_deduplication(
    documents: list[Document]
):
    new_docs = []
    new_ids = []

    existing_ids = set(
        vector_store.get()["ids"]
    )

    for doc in documents:
        content_hash = hashlib.sha256(
            doc.page_content.encode("utf-8")
        ).hexdigest()

        if content_hash not in existing_ids:
            new_docs.append(doc)
            new_ids.append(content_hash)
            existing_ids.add(content_hash)

    if new_docs:
        vector_store.add_documents(
            documents=new_docs,
            ids=new_ids
        )
        print(
            f"✅ {len(new_docs)} yeni benzersiz "
            "parça eklendi."
        )
    else:
        print(
            "ℹ️ Tüm dokümanlar zaten mevcut."
        )

import chainlit as cl
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import OllamaEmbeddings
from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

embedding_function = OllamaEmbeddings(
    model="bge-m3:latest",
    base_url="http://localhost:11434"
)

vector_store = Chroma(
    collection_name="pdf_rag_app",
    embedding_function=embedding_function,
    persist_directory="./pdf_chroma_db"
)

llm = ChatAnthropic(
    model="claude-3-5-sonnet-20240620",
    temperature=0.1
)

@cl.step(
    type="retriever",
    name="Vector DB Search"
)
async def retrieve_context(query: str):
    docs = vector_store.similarity_search(
        query,
        k=3
    )

    context_text = "\n\n---\n\n".join(
        d.page_content for d in docs
    )

    cl.user_session.set(
        "retrieved_docs",
        docs
    )

    return context_text

@cl.on_chat_start
async def on_start():
    files = None

    while files is None:
        files = await cl.AskFileMessage(
            content="PDF yükleyin:",
            accept=["application/pdf"],
            max_size_mb=20,
            timeout=180
        ).send()

    file = files[0]

    msg = cl.Message(
        content=f"📄 `{file.name}` işleniyor..."
    )

    await msg.send()

    loader = PyPDFLoader(file.path)
    raw_docs = loader.load()

    splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=200
    )

    chunks = splitter.split_documents(
        raw_docs
    )

    vector_store.add_documents(chunks)

    msg.content = (
        f"✅ `{file.name}` başarıyla indekslendi "
        f"({len(chunks)} parça)."
    )

    await msg.update()

prompt_template = ChatPromptTemplate.from_messages([
    (
        "system",
        """
        Sen kurumsal bir doküman asistanısın.

        Aşağıda verilen BAĞLAM bilgisini kullanarak
        kullanıcının sorusunu yanıtla.

        Eğer verilen bağlamda cevap YOKSA,
        kesinlikle bilgi uydurma.

        Şu yanıtı ver:
        'Verilen dokümanda bu konuyla ilgili
        yeterli bilgi bulunmamaktadır.'

        BAĞLAM:
        {context}
        """
    ),
    ("user", "{question}")
])

chain = (
    prompt_template
    | llm
    | StrOutputParser()
)

version: '3.8'

services:
  ollama_engine:
    image: ollama/ollama:latest
    container_name: local_ollama_server
    restart: always

    ports:
      - "11434:11434"

    volumes:
      - ./ollama_storage:/root/.ollama

    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

# Model indir
ollama pull llama3.1:8b

# Kurulu modelleri listele
ollama list

# Interaktif sohbet
ollama run llama3.1:8b

# Aktif modeller
ollama ps

# Base Model
FROM llama3.1:8b

# Hyperparameters
PARAMETER temperature 0.2
PARAMETER top_p 0.9
PARAMETER num_ctx 8192

# System Prompt
SYSTEM """
Sen 'CyberSec Assistant' adında
kurumsal bir siber güvenlik uzmanısın.

Sana sorulan sorulara yalnızca:
* siber güvenlik
* ağ güvenliği
* güvenli kodlama
çerçevesinde yanıt ver.

Konu dışı sorulara:
'Bu konu siber güvenlik kapsamım dışındadır.'
yanıtını ver.

Yanıtlarını Türkçe üret.
"""

ollama create cybersec-llama3 -f ./Modelfile

from langchain_community.chat_models import ChatOllama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Local Chat Model
local_llm = ChatOllama(
    base_url="http://localhost:11434",
    model="cybersec-llama3",
    temperature=0.1,
    num_ctx=8192
)

# Local Embedding Model
local_embeddings = OllamaEmbeddings(
    base_url="http://localhost:11434",
    model="bge-m3:latest"
)

# Prompt
prompt = ChatPromptTemplate.from_messages([
    (
        "system",
        "Sana verilen sorguları dikkatle analiz et."
    ),
    ("user", "{input}")
])

# LCEL Chain
cyber_chain = (
    prompt
    | local_llm
    | StrOutputParser()
)

async def main():
    query = (
        "SQL Injection saldırılarına karşı "
        "Python FastAPI'de nasıl önlem alınır?"
    )

    print(
        "🤖 Yerel LLM Yanıtı Üretiliyor..."
    )

    async for chunk in cyber_chain.astream({
        "input": query
    }):
        print(
            chunk,
            end="",
            flush=True
        )