### Instruction:
Develop a Python-based REST API using Flask that allows users to perform CRUD operations on a collection of items stored in a SQLite database. Include Swagger/OpenAPI documentation for the API endpoints. PLAINFORMAT

### Response:

```python
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import Marshmallow
from flask_swagger_ui import get_swaggerui_blueprint

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///items.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
ma = Marshmallow(app)

class Item(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), unique=True)
    description = db.Column(db.String(200))

    def __init__(self, name, description):
        self.name = name
        self.description = description

db.create_all()

class ItemSchema(ma.Schema):
    class Meta:
        fields = ('id', 'name', 'description')

item_schema = ItemSchema()
items_schema = ItemSchema(many=True)

@app.route('/api/items', methods=['POST'])
def add_item():
    name = request.json['name']
    description = request.json['description']

    new_item = Item(name, description)
    db.session.add(new_item)
    db.session.commit()

    return item_schema.jsonify(new_item)

@app.route('/api/items', methods=['GET'])
def get_items():
    all_items = Item.query.all()
    result = items_schema.dump(all_items)
    return jsonify(result)

@app.route('/api/items/<id>', methods=['GET'])
def get_item(id):
    item = Item.query.get(id)
    if not item:
        return jsonify({'message': 'Item not found'}), 404
    return item_schema.jsonify(item)

@app.route('/api/items/<id>', methods=['PUT'])
def update_item(id):
    item = Item.query.get(id)
    if not item:
        return jsonify({'message': 'Item not found'}), 404

    item.name = request.json['name']
    item.description = request.json['description']

    db.session.commit()
    return item_schema.jsonify(item)

@app.route('/api/items/<id>', methods=['DELETE'])
def delete_item(id):
    item = Item.query.get(id)
    if not item:
        return jsonify({'message': 'Item not found'}), 404

    db.session.delete(item)
    db.session.commit()

    return item_schema.jsonify(item)

SWAGGER_URL = '/api/docs'
API_URL = '/static/swagger.json'

swaggerui_blueprint = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_URL,
    config={
        'app_name': "Items API"
    }
)

app.register_blueprint(swaggerui_blueprint, url_prefix=SWAGGER_URL)

if __name__ == '__main__':
    app.run(debug=True)
```

Create a `swagger.json` file in the `/static` folder with the following content:

```json
{
  "swagger": "2.0",
  "info": {
    "title": "Items API",
    "version": "1.0"
  },
  "paths": {
    "/api/items": {
      "get": {
        "summary": "Get all items",
        "responses": {
          "200": {
            "description": "A list of items"
          }
        }
      },
      "post": {
        "summary": "Add an item",
        "parameters": [
          {
            "in": "body",
            "name": "item",
            "schema": {
              "$ref": "#/definitions/Item"
            }
          }
        ],
        "responses": {
          "201": {
            "description": "The created item"
          }
        }
      }
    },
    "/api/items/{id}": {
      "get": {
        "summary": "Get an item by ID",
        "parameters": [
          {
            "in": "path",
            "name": "id",
            "type": "integer"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested item"
          },
          "404": {
            "description": "Item not found"
          }
        }
      },
      "put": {
        "summary": "Update an item by ID",
        "parameters": [
          {
            "in": "path",
            "name": "id",
            "type": "integer"
          },
          {
            "in": "body",
            "name": "item",
            "schema": {
              "$ref": "#/definitions/Item"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The updated item"
          },
          "404": {
            "description": "Item not found"
          }
        }
      },
      "delete": {
        "summary": "Delete an item by ID",
        "parameters": [
          {
            "in": "path",
            "name": "id",
            "type": "integer"
          }
        ],
        "responses": {
          "200": {
            "description": "The deleted item"
          },
          "404": {
            "description": "Item not found"
          }
        }
      }
    }
  },
  "definitions": {
    "Item": {
      "type": "object",
      "properties": {
        "id": {
          "type": "integer"
        },
        "name": {
          "type": "string"
        },
        "description": {
          "type": "string"
        }
      }
    }
  }
}
```