$ ollama --help

Large language model runner

Usage:
  ollama [flags]
  ollama [command]

Available Commands:
  serve       Start ollama
  create      Create a model from a Modelfile
  show        Show information for a model
  run         Run a model
  pull        Pull a model from a registry
  push        Push a model to a registry
  list        List models
  cp          Copy a model
  rm          Remove a model
  help        Help about any command

Flags:
  -h, --help      help for ollama
  -v, --version   Show version information

Use "ollama [command] --help" for more information about a command.

$ ollama show deepseek-coder --system

You are an AI programming assistant, utilizing the Deepseek Coder model, 
developed by Deepseek Company, 
and you only answer questions related to computer science. 
For politically sensitive questions, security and privacy issues, 
and other non-computer science questions, you will refuse to answer.

$ ollama run deepseek-coder
>>> Make a simple Fast API server in Python with one health check endpoint.

Here is an example of how we can implement it using the Starlette (ASGI) web framework for python that 
provides us great flexibility and scalability when developing APIs, including its built-in support to 
provide HTTP HEAD requests on /healthcheck endpoints which FastAPI uses by default. 
This endpoint will return a simple "200 OK" response if the server is running correctly:

```python
from fastapi import FastAPI
app = FastAPI()

@app.get("/")
async def root():
    return {
   "message": "Hello World"}

@app.get("/healthcheck", status_code=200)  # Specify HTTP HEAD request here as default is GET which can't
be used in the same way for health check requests  
def read_root() -> dict:   
    return {
   "status": "up"}     
```    

This server will respond with a message to "/" and always say that it’s up when accessed through 
/healthcheck.  Please note this endpoint is not available on default configuration of FastAPI as by 
design, the root endpoints (like '/' or '') do NOT provide additional information about health check 
requests - they are designed for system status only

>>> how do I run the code?
Once you've installed all necessary dependencies, here are general steps on how to start your FastAPI server and its health check endpoint 
using Uvicorn. 
This example assumes that `uvicorn main:app --host=0.0.0.0 --port=8001` is the command you run in terminal for development purposes, where 
"main" refers back to our python file from which FastAPI app was created (in this case it's called 'run') and `--reload` will refresh your 
server every time there are changes made.

You can then use curl commands like below for health checking of running app.   Replace 'localhost' and ':8001' with your server hostname &
port if they are different:    `curl http://localhost:8001/healthcheck -X HEAD ` (Use "-v" option to see more detailed response)
```bash 
# Run this command in terminal   --> For checking the health of FastAPI app.    You should be able get a "2xx OK" message if server is 
running correctly and it's healthy, otherwise you would expect different responses from /healthcheck endpoint or have some sort of error 
logs present indicating issues with your application starting up
curl http://localhost:8001/healthcheck -X HEAD  & python utils.log_handler   #--> this will log health check response in the file specified
(defaults to ./logs)    you can run above commands at least once and then try running FastAPI server again, it should provide more detailed
logs indicating whether app is up or not
```     

In both of these cases I've used HEAD request as we need only status information without actual content. It would be different if 
the endpoint requires a specific format/content type (like POST with json in above curl commands), then use `-d 'json={"key":"value"}' -H 
"Content-Type: application/json"'` instead to send data or JSON payload, depending on what your health check request actually needs.

curl -X POST http://localhost:11434/api/generate -d '{
  "model": "deepseek-coder",
  "prompt": "Make a simple Python script to add two numbers."
}'

import requests
import json

url = "http://localhost:11434/api/generate"
headers = {
    'Content-Type': 'application/json',
}
conversation_history = []

while True:
    print('Code with Deepseek Coder:')
    user_input = input("You: ")
    if user_input.lower() in ["quit", "exit"]:
        print("Exiting conversation.")
        break

    conversation_history.append(user_input)
    full_prompt = "\n".join(conversation_history)
    data = {
        "model": "deepseek-coder",
        "stream": False,
        "prompt": full_prompt,
    }

    response = requests.post(url, headers=headers, data=json.dumps(data))
    if response.status_code == 200:
        response_data = response.json()
        ai_response = response_data["response"]
        print("AI:", ai_response)
        conversation_history.append(ai_response)
    else:
        print(f"Error: {response.status_code} - {response.text}")

$ python3 main.py

Code with Deepseek Coder:
You: make a simple python script to add two numbers

AI: Sure! Here's a very basic Python program that takes in user inputs for the first number (num1) and then second number(Num2). It adds them together using an addition operation, prints out the result. 
Here is your requested code snippet :
```python
# Taking input from users/receiver of output stream by terminal or command line interface
print("Enter First Number: ") # prompt to enter first nummber  
num1 = float(input())    # user's response (both numbers) are stored in variable 'a'.  Typecast is necessary because we can get an input as string, so a number should be there.

# Input for the second numeric data type has to match with datatype of first numeral provided by users/receiver     # prompts user enter Second Number  
print("Enter The Another Nummber: ") 
num2 = float(input())    # same as above, this time we are getting input from terminal or command line interface. It is stored in variable 'b' and typecast to make sure it can perform an addition operation with the numbers provided by user  

# performing Addition of two inputs 
sum_of = num1 + num2    # sum equals first number added second one (numbers)    
print("The Sum is : ", sum_of )      # print out result. The program will output a text message saying the numbers and their sums   when we run this code in python console/terminal or IDEs like PyCharm, etc   
```  
You can copy paste it into your Python environment where you have an active internet connection (Python Repl is recommended). If not connected to any web server then replace "input" with just a number. It will work as long both numbers are numeric in nature ie., integers or floats, etc..

# Taking input from users/receiver of output stream by terminal or command line interface
print("Enter First Number: ") # prompt to enter first nummber  
num1 = float(input())    # user's response (both numbers) are stored in variable 'a'.  Typecast is necessary because we can get an input as string, so a number should be there.

# Input for the second numeric data type has to match with datatype of first numeral provided by users/receiver     # prompts user enter Second Number  
print("Enter The Another Nummber: ") 
num2 = float(input())    # same as above, this time we are getting input from terminal or command line interface. It is stored in variable 'b' and typecast to make sure it can perform an addition operation with the numbers provided by user  

# performing Addition of two inputs 
sum_of = num1 + num2    # sum equals first number added second one (numbers)    
print("The Sum is : ", sum_of )      # print out result. The program will output a text message saying the numbers and their sums   when we run this code in python console/terminal or IDEs like PyCharm, etc