---
rel_ver: 0.7.0
layout: release-notes
---

<!--
 Licensed to the Apache Software Foundation (ASF) under one or more
 contributor license agreements.  See the NOTICE file distributed with
 this work for additional information regarding copyright ownership.
 The ASF licenses this file to You under the Apache License, Version 2.0
 (the "License"); you may not use this file except in compliance with
 the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
-->

<section id="overview">
    <h2 class="section-title">Overview</h2>
    <p>
        <a href="/download.html">NLPCraft 0.7.0</a> brings about several important features:
    </p>
    <ul>
        <li>
            The project has moved to JDK 11+ Java version and therefore is no longer compatible with previous
            versions or prior JDK version.
        </li>
        <li>
            We introduced <a target="javadoc" href="/apis/latest/org/apache/nlpcraft/model/NCIntentSample.html">@NCIntentSample</a> annotation
            that is broadly used throughout the project:
            <ul>
                <li>In model auto-validation.</li>
                <li>In the new synonym suggestion tool.</li>
                <li>In the upcoming BERT-based server side enricher.</li>
            </ul>
        </li>
        <li>
            We introduced model <a href="/tools/test_framework.html">auto-validation</a> based on <a target="javadoc" href="/apis/latest/org/apache/nlpcraft/model/NCIntentSample.html">@NCIntentSample</a> annotation
            that allows for zero-code testing of the models (all shipped examples have been updated accordingly).
        </li>
        <li>
            We introduced <a href="/tools/syn_tool.html">synonym suggestion tool</a> that takes an existing model, analyses its synonyms and intents and comes up
            with a list of synonyms that are currently missing that you might want to add to your model.
        </li>
        <li>
            We've added a preview of the upcoming REPL tool for NLPCraft (see <code>nlpcraft.{shg|cmd}</code> scripts in the bin folder)
            and corresponding ASCI/ANSI support for both server and probe log output.
        </li>
    </ul>
</section>
<section id="new">
    <h2 class="section-title">🙌 New</h2>
    <ul>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-12'>NLPCRAFT-12</a> - Introduce &#39;not&#39; function. </li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-41'>NLPCRAFT-41</a> - Synonyms suggestion tool.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-42'>NLPCRAFT-42</a> - Model examples validation.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-67'>NLPCRAFT-67</a> - Python machine learning module.</li>
    </ul>
</section>
<section id="enhancements">
    <h2 class="section-title">🤖 Enhancements</h2>
    <ul>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-51'>NLPCRAFT-51</a> - Add SqlGen tool documentation.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-52'>NLPCRAFT-52</a> - Add test framework documentation.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-65'>NLPCRAFT-65</a> - Add embedded probe documentation.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-68'>NLPCRAFT-68</a> - Add more examples to all example models.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-73'>NLPCRAFT-73</a> - Add new maven profile for GridGain Control Center Agent.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-79'>NLPCRAFT-79</a> - Fix docs/website links due to new sub-module structure of the project.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-80'>NLPCRAFT-80</a> - Add <code>@NCIntentSample</code> annotation + support in test framework and static synonym tool.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-81'>NLPCRAFT-81</a> - Resolve licensing issues for the release.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-94'>NLPCRAFT-94</a> - Remove global model examples.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-97'>NLPCRAFT-97</a> - Add MIT to LICENSE file.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-98'>NLPCRAFT-98</a> - Move OpenNLP models from official release.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-99'>NLPCRAFT-99</a> - Update website docs.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-107'>NLPCRAFT-107</a> - Move embedded probe into &#39;tools&#39; package.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-112'>NLPCRAFT-112</a> - Migrate to Java 11+.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-113'>NLPCRAFT-113</a> - We need a full coverage automated test for REST APIs.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-114'>NLPCRAFT-114</a> - Review usage of scala <code>Future.collect()</code> method in the project.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-115'>NLPCRAFT-115</a> - org.apache.nlpcraft.probe.mgrs.deploy.NCModelHolder</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-116'>NLPCRAFT-116</a> - Convert &#39;tokenProviders&#39; and &#39;lifecycle&#39; to CSV strings in <code>nlpcraft.conf</code>.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-117'>NLPCRAFT-117</a> - Time example fails auto-validation.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-118'>NLPCRAFT-118</a> - Insufficient <code>NCIntentTerm</code> validation.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-120'>NLPCRAFT-120</a> - Intent samples are not validated for dups.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-122'>NLPCRAFT-122</a> - Add JANSI support for console output.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-131'>NLPCRAFT-131</a> - Add test for synonyms suggestion manager, which checks <code>minScore</code> result.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-132'>NLPCRAFT-132</a> - Disable weather model test when running on CI.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-133'>NLPCRAFT-133</a> - Model auto validator doesn't exit JVM process (threads stuck in some pool).</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-134'>NLPCRAFT-134</a> - 'mvn verify' executes many tests multiple times.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-135'>NLPCRAFT-135</a> - Ability to add user data to conversation.</li>
    </ul>
</section>
<section id="fixes">
    <h2 class="section-title">🧐 Fixes</h2>
    <ul>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-3'>NLPCRAFT-3</a> - Finish example documentation.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-62'>NLPCRAFT-62</a> - Tests failed.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-63'>NLPCRAFT-63</a> - Integration tests under windows.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-64'>NLPCRAFT-64</a> - Examples model tests.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-72'>NLPCRAFT-72</a> - POM fixes (make Stanford dependencies optional).</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-74'>NLPCRAFT-74</a> - Weather example does not work sometimes due to the external dependency.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-77'>NLPCRAFT-77</a> - Ignite cache should be cleared before suite started.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-84'>NLPCRAFT-84</a> - SQL example. Improve sql statement generation.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-85'>NLPCRAFT-85</a> - Profiles for Geo and  Spell data.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-86'>NLPCRAFT-86</a> - Update release manual.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-87'>NLPCRAFT-87</a> - Probe start-up time improvements.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-90'>NLPCRAFT-90</a> - NCUtils 'read' methods. Resources should be closed.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-95'>NLPCRAFT-95</a> - Move examples tests from 'src' folder.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-103'>NLPCRAFT-103</a> - Slow down when starting server on Windows 10.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-104'>NLPCRAFT-104</a> - Class <code>NCTokenLogger</code> has many duplicate code warnings.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-106'>NLPCRAFT-106</a> - SLQ example ascii table output does not work on Windows 10.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-110'>NLPCRAFT-110</a> - Weather example error.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-119'>NLPCRAFT-119</a> - <code>NCConfigurable</code> exceptions.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-121'>NLPCRAFT-121</a> - Probe cannot be stopped.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-127'>NLPCRAFT-127</a> - Fix sort enricher handling of sort direction.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-128'>NLPCRAFT-128</a> - Fix <code>super.start()</code> and <code>super.stop()</code> in <code>NCService</code> sub-classes.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-136'>NLPCRAFT-136</a> - Invalid error log line.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-100'>NLPCRAFT-100</a> - Update libraries version.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-123'>NLPCRAFT-123</a> - Review all non-ascii symbols usage in messages.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-124'>NLPCRAFT-124</a> - Extend test framework.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-126'>NLPCRAFT-126</a> - Errors log messages during stop probe should be hidden.</li>
        <li><a target="jira" href='https://issues.apache.org/jira/browse/NLPCRAFT-130'>NLPCRAFT-130</a> - Too short errors logs.</li>
    </ul>
</section>

