app.py

from flask import Flask
from flask import render_template, request, jsonify
from datetime import datetime
import re
import flask_sqlalchemy

# persistence with SQLite via SQLAlchemy
from flask_sqlalchemy import SQLAlchemy

# local Ollama client wrapper
from chat import ollama_client


app = Flask(__name__)

# configure database (SQLite file in project root)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///chat_history.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# make sure the instance path exists (SQLite file will live here)
import os

# ensure instance directory exists (Flask uses this for SQLite file)
os.makedirs(app.instance_path, exist_ok=True)

# initialize ORM
db = SQLAlchemy(app)


# simple model for storing chat messages
class ChatEntry(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    role = db.Column(db.String(10), nullable=False)
    content = db.Column(db.Text, nullable=False)
    timestamp = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)

    def to_dict(self):
        return {
            'id': self.id,
            'role': self.role,
            'content': self.content,
            'timestamp': self.timestamp.isoformat(),
        }


# create database tables now that models are defined
with app.app_context():
    db.create_all()


# Home page
@app.route("/")
def home():
    return render_template("home.html")

# About page
@app.route("/about/")
def about():
    return render_template("about.html")

# Contact page
@app.route("/contact/")
def contact():
    return render_template("contact.html")

@app.route("/hello")
@app.route("/hello/<name>")
def hello_there(name = None):
    return render_template(
        "hello_there.html",
        name = name,
        date = datetime.now()
    )

@app.route("/api/data")
def get_data():
    return app.send_static_file("data.json")


@app.route('/chat', methods=['GET'])
def chat_health():
    """Health-check for the Ollama server.

    Returns 200 when available, 503 when not.
    """
    ok = ollama_client.is_server_available()
    status = {"ollama_available": ok}
    return jsonify(status), (200 if ok else 503)


@app.route('/chat', methods=['POST'])
def chat_route():
    """Simple JSON POST endpoint that proxies messages to Ollama.

    Expected JSON body: {"messages": [{"role":"user","content":"..."}, ...], "model": "llama3"}
    """
    data = request.get_json(force=True, silent=True)
    if not data:
        return jsonify({"error": "invalid or missing JSON body"}), 400

    messages = data.get('messages')
    model = data.get('model', 'llama3')
    if not isinstance(messages, list):
        return jsonify({"error": "'messages' must be a list"}), 400

    try:
        # persist incoming messages
        for msg in messages:
            entry = ChatEntry(role=msg.get('role', ''), content=msg.get('content', ''))
            db.session.add(entry)

        result = ollama_client.chat(messages=messages, model=model)

        # if response contains a reply, store it as well
        reply_text = None
        if isinstance(result, dict):
            reply_text = result.get('reply') or result.get('result')
        if reply_text:
            db.session.add(ChatEntry(role='assistant', content=reply_text))

        db.session.commit()
        return jsonify(result)
    except RuntimeError as e:
        db.session.rollback()
        return jsonify({"error": str(e)}), 503
    except Exception as e:
        db.session.rollback()
        return jsonify({"error": "internal error", "detail": str(e)}), 500


@app.route('/chat_history')
def chat_history():
    """Return stored chat conversation as JSON list."""
    entries = ChatEntry.query.order_by(ChatEntry.timestamp).all()
    return jsonify([e.to_dict() for e in entries])


@app.route('/chat_ui')
def chat_ui():
    """Render the simple browser-based chat UI."""
    return render_template('chat.html')


if __name__ == '__main__':
    # run via `python app.py` for convenience during development
    app.run(debug=True)