This section provides an overview of the key tools that are expected to address the Semantic Infrastructure requirements. Tools are a combination of applications, user interfaces and services that address a specific Semantic Infrastructure requirement. The tool description provides a user view of how the tools may be used to perform specific tasks.
This section includes the following:
ECCF Registry and User Interface
The ECCF registry interface will provide a single interface for accessing all the artifacts and service metadata. Users will be able to use the interface to perform:
Artifact Search and Access
- Search the registry for model
- Search CTS 2 for existing value sets
- Search the OID registry for an appropriate identifier route
- Retrieve an existing model from the registry
- Retrieve schemas and form definitions
- Import a new model for annotation (binding to terminology and value-sets)
- Retrieve the value set from CTS 2 and apply to the model attributes
Artifact Authoring
- Create a new value set (leveraging terminology services) and manage existing artifacts
- Register the object identifier with its metadata
- Register a new artifact in the registry with its metadata (including ECCF specific information), traceability to support provenance
- Link the models to existing models, domains, or both and classify artifacts
- Constrain existing models
- Constrain existing data-types
- Link artifacts to service specifications
- Dupport collaborative development of metadata
Artifact Governance and Lifecycle Management
- Initiate artifact workflow
- Monitor the workflow process
- Allow curators to set the status of a model and receive change notifications
- Customize review and approval workflows
- Govern collaborative development
Artifact Analysis
- Execute semantic queries for search and analysis
Access Control and Policy Management
- Establish templates and policies that can be applied to artifacts
- Link the users security and access rights to a particular governance and workflow
- Execute semantic queries for analysis
- Identify dependencies
Search and Access Services
- Discover services
- Execute complex queries to identify services
- Discover contracts at runtime
Administer Services and Specifications
- Create a new service specification
- Create and edit service metadata
- Link the artifacts to the service specification
- Construct conformance statements
- Run validations on specification and supporting artifacts
- Apply constraints, rules and policies
- Constrain and reuse existing specifications and artifacts
Analyze Services
- Execute semantic queries for analysis
- Perform impact analysis to identify dependencies and constraints
Service Governance and Workflows
- Initiate service specification governance
- Monitor the workflow and approval process
- Allow governance team to set the status of specification and promote
- Manage versioning and localization of the service specifications
- Govern collaborative development
Plug-ins, Loaders and Miscellaneous Development Tools
Plug-ins and development tools are extensions to existing tools to support better integration with the ECCF registry:
- Publish artifacts from eclipse and other modeling tools to the ECCF registry
- Publish content from external tools to the ECCF registry, with support for topic maps and DITA
- Extract and load metadata from artifacts into registry
Forms Editor
An end user tool for creating and editing forms:
- Create form definitions
- Retrieve models, data-types and value-sets
- Define skip patterns, layout and display options
- Publish forms to ECCF registry
- Reuse and leverage predefined templates
Conformance Testing Framework
A testing framework for developing automated test scripts that can be executed against an artifact or service.
- Retrieve artifact metadata and conformance statements
- Generate test scripts
- Execute conformance tests
- Generate conformance report
Knowledge Based Systems Support Tools
A set of knowledge engineering tools to support reasoning and inference use cases.
- Knowledge Representation Definition
- Rule Pattern Definition
- Domain Model Development
- Knowledge Base Model Definition
- Fact Generation and Mapping tooling
- Rule Generation tooling
- Reasoner Framework for Standard Knowledge-based System Development
- Automated Reasoning Service Publication
Legend for Diagram Above
Components for Development |
|
Box name:UML Transformation |
The UML transformation process takes a standard UML representation (XMI) of a model and performs analysis to determine semantics and definitions. |
Box name:XML Transformation |
The XML transformation process takes XML Schemas and XML instances to generate and determine semantics and definitions. |
Box name:RDF/OWL Librarian |
The librarian is responsible for knowing what definitions are represented in the registry. In addition, the librarian is responsible for versioning and representation of the governance process. |
Box name:Transformation/Extraction Cache Controller |
The cache controller is used to improve performance and interactions of the various components. Since reasoning systems may require the merging of large amounts of knowledge, the controller will prevent unnecessary fetching operations. |
Box name:DIFF Tool |
The DIFF tool provides a number of functional behaviors such as determining differences between two versions of semantic representations. In addition, the diff tool looks at the semantics to determine if two systems of representations may have common areas of interest. |
Box name:Reasoner Controller |
Manages the reasoner configurations and implementations so when called upon they are properly configured. |
Box name:Reasoner Orchestration Tool |
The orchestration tool provides integration between reasoners. This allows for the staging of reasoning systems to allow for concurrent or parallel processing of reasoning systems.. |
Box name:Reasoner Session Manager |
Since users may perform interaction with the reasoning systems with specific knowledge stores and reasoner configurations, the session manager maintains the state and processes until the user or system no longer requires it. |
Box name:ECCF KM API |
The set of functional APIs that can be called by applications. |
Box name:ECCF KM Remote Service API |
The set of remote service APIs that are called by applications. These set of service calls include appropriate implementations such as SOAP and RESTful services. |
Box name:ECCF KM Web Interface |
The Web interface is a web application that users can use to interact with the Knowledge Manager. From this application users can upload knowledge sources for processing by the reasoners, download semantic representations of processed models and schemas, as well as perform direct queries against the knowledge stores. |
Data Stores |
|
Box name:RDBMS Store |
This is information stored in traditional RDBMS stores with traditional schemas. Semantic access to these system will be performed using the open source tools. |
Box name:Triple Store |
The most flexible representation of semantic information is stored in a triple store. There are multiple possible physical representations including files, RDBMS triple stores, and dedicated high performance triple stores. |
Open source components |
|
Box name:Jena |
Jena is a standard interface tool that allows for the access of triple store information in RDF and OWL formats. Jena is a very flexible tool with the ability to interact with the stores with various reasoners. |
Box name:ARQ (SPARQL) |
ARQ is an implementation of the SPARQL language. SPARQL provides a standardized query language for interacting with triple stores. |
Box name:Pellet |
Pellet is an OWL 2 reasoner. Pellet provides standard and reasoning services for OWL ontologies. |
Box name:FaCT ++ |
FaCT++ is an OWL DL reasoner (partially OWL 2), is implemented in C++ and uses optimized tableaux algorithms. |
Box name\:D2RQ |
A tool, which works with traditional RDBMS structures and presents them using RDF semantics. This allows for SPARQL queries of RDMS data, as well as integration with reasoning systems. |
Box name:Other Reasoners |
The jena tool provides for integrations with alternative reasonsers, which can be determined later. |
